This is page 3 of 3. Use http://codebase.md/bmorphism/krep-mcp-server?page={x} to view the full context.

# Directory Structure

```
├── .eslintrc.js
├── .prettierrc
├── CLAUDE_DESKTOP_INTEGRATION.md
├── eslint.config.js
├── MCP_COMPLIANCE.md
├── package.json
├── README.md
├── run-claude-integration.sh
├── src
│   ├── index.js
│   ├── index.min.js
│   ├── mcp_server.js
│   └── mcp_server.min.js
├── test
│   ├── benchmark.js
│   ├── fixtures
│   │   ├── large.txt
│   │   ├── sample.txt
│   │   └── subdir
│   │       └── test.txt
│   ├── integration
│   │   ├── mcp_advanced.test.js
│   │   ├── mcp_client_compatibility.test.js
│   │   ├── mcp_compliance.test.js
│   │   ├── mcp_uri_validation.test.js
│   │   ├── sdk_workflow.test.js
│   │   ├── sdk-integration.test.js
│   │   └── server.test.js
│   ├── mcp_benchmark.js
│   ├── mock-server.js
│   ├── unit
│   │   ├── algorithm_property.test.js
│   │   ├── algorithm.test.js
│   │   ├── api.test.js
│   │   ├── mcp_errors.test.js
│   │   └── run.test.js
│   └── utils.js
├── test-mcp-inspector.js
├── test-summary.md
└── THREAD_OPTIMIZATION.md
```

# Files

--------------------------------------------------------------------------------
/test/fixtures/large.txt:
--------------------------------------------------------------------------------

```
// Creating a larger file with repeated content for performance testingThis is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
It contains multiple lines with various patterns.
Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
This helps test case-insensitive searching.
The quick brown fox jumps over the lazy dog.
We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
Short patterns like ab should also be findable.
Single character patterns like 'a' appear frequently in this text.
We need to test boundaries as well, so here's some text at the end.
```