This is page 3 of 3. Use http://codebase.md/bmorphism/krep-mcp-server?lines=true&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:
--------------------------------------------------------------------------------
```
1 | // Creating a larger file with repeated content for performance testingThis is a sample text file for testing the krep-mcp-server.
2 | It contains multiple lines with various patterns.
3 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4 | This helps test case-insensitive searching.
5 | The quick brown fox jumps over the lazy dog.
6 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7 | Short patterns like ab should also be findable.
8 | Single character patterns like 'a' appear frequently in this text.
9 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
10 | It contains multiple lines with various patterns.
11 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
12 | This helps test case-insensitive searching.
13 | The quick brown fox jumps over the lazy dog.
14 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
15 | Short patterns like ab should also be findable.
16 | Single character patterns like 'a' appear frequently in this text.
17 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
18 | It contains multiple lines with various patterns.
19 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
20 | This helps test case-insensitive searching.
21 | The quick brown fox jumps over the lazy dog.
22 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
23 | Short patterns like ab should also be findable.
24 | Single character patterns like 'a' appear frequently in this text.
25 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
26 | It contains multiple lines with various patterns.
27 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
28 | This helps test case-insensitive searching.
29 | The quick brown fox jumps over the lazy dog.
30 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
31 | Short patterns like ab should also be findable.
32 | Single character patterns like 'a' appear frequently in this text.
33 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
34 | It contains multiple lines with various patterns.
35 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
36 | This helps test case-insensitive searching.
37 | The quick brown fox jumps over the lazy dog.
38 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
39 | Short patterns like ab should also be findable.
40 | Single character patterns like 'a' appear frequently in this text.
41 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
42 | It contains multiple lines with various patterns.
43 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
44 | This helps test case-insensitive searching.
45 | The quick brown fox jumps over the lazy dog.
46 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
47 | Short patterns like ab should also be findable.
48 | Single character patterns like 'a' appear frequently in this text.
49 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
50 | It contains multiple lines with various patterns.
51 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
52 | This helps test case-insensitive searching.
53 | The quick brown fox jumps over the lazy dog.
54 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
55 | Short patterns like ab should also be findable.
56 | Single character patterns like 'a' appear frequently in this text.
57 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
58 | It contains multiple lines with various patterns.
59 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
60 | This helps test case-insensitive searching.
61 | The quick brown fox jumps over the lazy dog.
62 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
63 | Short patterns like ab should also be findable.
64 | Single character patterns like 'a' appear frequently in this text.
65 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
66 | It contains multiple lines with various patterns.
67 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
68 | This helps test case-insensitive searching.
69 | The quick brown fox jumps over the lazy dog.
70 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
71 | Short patterns like ab should also be findable.
72 | Single character patterns like 'a' appear frequently in this text.
73 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
74 | It contains multiple lines with various patterns.
75 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
76 | This helps test case-insensitive searching.
77 | The quick brown fox jumps over the lazy dog.
78 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
79 | Short patterns like ab should also be findable.
80 | Single character patterns like 'a' appear frequently in this text.
81 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
82 | It contains multiple lines with various patterns.
83 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
84 | This helps test case-insensitive searching.
85 | The quick brown fox jumps over the lazy dog.
86 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
87 | Short patterns like ab should also be findable.
88 | Single character patterns like 'a' appear frequently in this text.
89 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
90 | It contains multiple lines with various patterns.
91 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
92 | This helps test case-insensitive searching.
93 | The quick brown fox jumps over the lazy dog.
94 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
95 | Short patterns like ab should also be findable.
96 | Single character patterns like 'a' appear frequently in this text.
97 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
98 | It contains multiple lines with various patterns.
99 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
100 | This helps test case-insensitive searching.
101 | The quick brown fox jumps over the lazy dog.
102 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
103 | Short patterns like ab should also be findable.
104 | Single character patterns like 'a' appear frequently in this text.
105 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
106 | It contains multiple lines with various patterns.
107 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
108 | This helps test case-insensitive searching.
109 | The quick brown fox jumps over the lazy dog.
110 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
111 | Short patterns like ab should also be findable.
112 | Single character patterns like 'a' appear frequently in this text.
113 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
114 | It contains multiple lines with various patterns.
115 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
116 | This helps test case-insensitive searching.
117 | The quick brown fox jumps over the lazy dog.
118 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
119 | Short patterns like ab should also be findable.
120 | Single character patterns like 'a' appear frequently in this text.
121 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
122 | It contains multiple lines with various patterns.
123 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
124 | This helps test case-insensitive searching.
125 | The quick brown fox jumps over the lazy dog.
126 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
127 | Short patterns like ab should also be findable.
128 | Single character patterns like 'a' appear frequently in this text.
129 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
130 | It contains multiple lines with various patterns.
131 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
132 | This helps test case-insensitive searching.
133 | The quick brown fox jumps over the lazy dog.
134 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
135 | Short patterns like ab should also be findable.
136 | Single character patterns like 'a' appear frequently in this text.
137 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
138 | It contains multiple lines with various patterns.
139 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
140 | This helps test case-insensitive searching.
141 | The quick brown fox jumps over the lazy dog.
142 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
143 | Short patterns like ab should also be findable.
144 | Single character patterns like 'a' appear frequently in this text.
145 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
146 | It contains multiple lines with various patterns.
147 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
148 | This helps test case-insensitive searching.
149 | The quick brown fox jumps over the lazy dog.
150 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
151 | Short patterns like ab should also be findable.
152 | Single character patterns like 'a' appear frequently in this text.
153 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
154 | It contains multiple lines with various patterns.
155 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
156 | This helps test case-insensitive searching.
157 | The quick brown fox jumps over the lazy dog.
158 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
159 | Short patterns like ab should also be findable.
160 | Single character patterns like 'a' appear frequently in this text.
161 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
162 | It contains multiple lines with various patterns.
163 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
164 | This helps test case-insensitive searching.
165 | The quick brown fox jumps over the lazy dog.
166 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
167 | Short patterns like ab should also be findable.
168 | Single character patterns like 'a' appear frequently in this text.
169 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
170 | It contains multiple lines with various patterns.
171 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
172 | This helps test case-insensitive searching.
173 | The quick brown fox jumps over the lazy dog.
174 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
175 | Short patterns like ab should also be findable.
176 | Single character patterns like 'a' appear frequently in this text.
177 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
178 | It contains multiple lines with various patterns.
179 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
180 | This helps test case-insensitive searching.
181 | The quick brown fox jumps over the lazy dog.
182 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
183 | Short patterns like ab should also be findable.
184 | Single character patterns like 'a' appear frequently in this text.
185 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
186 | It contains multiple lines with various patterns.
187 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
188 | This helps test case-insensitive searching.
189 | The quick brown fox jumps over the lazy dog.
190 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
191 | Short patterns like ab should also be findable.
192 | Single character patterns like 'a' appear frequently in this text.
193 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
194 | It contains multiple lines with various patterns.
195 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
196 | This helps test case-insensitive searching.
197 | The quick brown fox jumps over the lazy dog.
198 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
199 | Short patterns like ab should also be findable.
200 | Single character patterns like 'a' appear frequently in this text.
201 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
202 | It contains multiple lines with various patterns.
203 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
204 | This helps test case-insensitive searching.
205 | The quick brown fox jumps over the lazy dog.
206 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
207 | Short patterns like ab should also be findable.
208 | Single character patterns like 'a' appear frequently in this text.
209 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
210 | It contains multiple lines with various patterns.
211 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
212 | This helps test case-insensitive searching.
213 | The quick brown fox jumps over the lazy dog.
214 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
215 | Short patterns like ab should also be findable.
216 | Single character patterns like 'a' appear frequently in this text.
217 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
218 | It contains multiple lines with various patterns.
219 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
220 | This helps test case-insensitive searching.
221 | The quick brown fox jumps over the lazy dog.
222 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
223 | Short patterns like ab should also be findable.
224 | Single character patterns like 'a' appear frequently in this text.
225 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
226 | It contains multiple lines with various patterns.
227 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
228 | This helps test case-insensitive searching.
229 | The quick brown fox jumps over the lazy dog.
230 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
231 | Short patterns like ab should also be findable.
232 | Single character patterns like 'a' appear frequently in this text.
233 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
234 | It contains multiple lines with various patterns.
235 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
236 | This helps test case-insensitive searching.
237 | The quick brown fox jumps over the lazy dog.
238 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
239 | Short patterns like ab should also be findable.
240 | Single character patterns like 'a' appear frequently in this text.
241 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
242 | It contains multiple lines with various patterns.
243 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
244 | This helps test case-insensitive searching.
245 | The quick brown fox jumps over the lazy dog.
246 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
247 | Short patterns like ab should also be findable.
248 | Single character patterns like 'a' appear frequently in this text.
249 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
250 | It contains multiple lines with various patterns.
251 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
252 | This helps test case-insensitive searching.
253 | The quick brown fox jumps over the lazy dog.
254 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
255 | Short patterns like ab should also be findable.
256 | Single character patterns like 'a' appear frequently in this text.
257 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
258 | It contains multiple lines with various patterns.
259 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
260 | This helps test case-insensitive searching.
261 | The quick brown fox jumps over the lazy dog.
262 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
263 | Short patterns like ab should also be findable.
264 | Single character patterns like 'a' appear frequently in this text.
265 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
266 | It contains multiple lines with various patterns.
267 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
268 | This helps test case-insensitive searching.
269 | The quick brown fox jumps over the lazy dog.
270 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
271 | Short patterns like ab should also be findable.
272 | Single character patterns like 'a' appear frequently in this text.
273 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
274 | It contains multiple lines with various patterns.
275 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
276 | This helps test case-insensitive searching.
277 | The quick brown fox jumps over the lazy dog.
278 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
279 | Short patterns like ab should also be findable.
280 | Single character patterns like 'a' appear frequently in this text.
281 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
282 | It contains multiple lines with various patterns.
283 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
284 | This helps test case-insensitive searching.
285 | The quick brown fox jumps over the lazy dog.
286 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
287 | Short patterns like ab should also be findable.
288 | Single character patterns like 'a' appear frequently in this text.
289 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
290 | It contains multiple lines with various patterns.
291 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
292 | This helps test case-insensitive searching.
293 | The quick brown fox jumps over the lazy dog.
294 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
295 | Short patterns like ab should also be findable.
296 | Single character patterns like 'a' appear frequently in this text.
297 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
298 | It contains multiple lines with various patterns.
299 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
300 | This helps test case-insensitive searching.
301 | The quick brown fox jumps over the lazy dog.
302 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
303 | Short patterns like ab should also be findable.
304 | Single character patterns like 'a' appear frequently in this text.
305 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
306 | It contains multiple lines with various patterns.
307 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
308 | This helps test case-insensitive searching.
309 | The quick brown fox jumps over the lazy dog.
310 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
311 | Short patterns like ab should also be findable.
312 | Single character patterns like 'a' appear frequently in this text.
313 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
314 | It contains multiple lines with various patterns.
315 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
316 | This helps test case-insensitive searching.
317 | The quick brown fox jumps over the lazy dog.
318 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
319 | Short patterns like ab should also be findable.
320 | Single character patterns like 'a' appear frequently in this text.
321 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
322 | It contains multiple lines with various patterns.
323 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
324 | This helps test case-insensitive searching.
325 | The quick brown fox jumps over the lazy dog.
326 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
327 | Short patterns like ab should also be findable.
328 | Single character patterns like 'a' appear frequently in this text.
329 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
330 | It contains multiple lines with various patterns.
331 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
332 | This helps test case-insensitive searching.
333 | The quick brown fox jumps over the lazy dog.
334 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
335 | Short patterns like ab should also be findable.
336 | Single character patterns like 'a' appear frequently in this text.
337 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
338 | It contains multiple lines with various patterns.
339 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
340 | This helps test case-insensitive searching.
341 | The quick brown fox jumps over the lazy dog.
342 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
343 | Short patterns like ab should also be findable.
344 | Single character patterns like 'a' appear frequently in this text.
345 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
346 | It contains multiple lines with various patterns.
347 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
348 | This helps test case-insensitive searching.
349 | The quick brown fox jumps over the lazy dog.
350 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
351 | Short patterns like ab should also be findable.
352 | Single character patterns like 'a' appear frequently in this text.
353 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
354 | It contains multiple lines with various patterns.
355 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
356 | This helps test case-insensitive searching.
357 | The quick brown fox jumps over the lazy dog.
358 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
359 | Short patterns like ab should also be findable.
360 | Single character patterns like 'a' appear frequently in this text.
361 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
362 | It contains multiple lines with various patterns.
363 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
364 | This helps test case-insensitive searching.
365 | The quick brown fox jumps over the lazy dog.
366 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
367 | Short patterns like ab should also be findable.
368 | Single character patterns like 'a' appear frequently in this text.
369 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
370 | It contains multiple lines with various patterns.
371 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
372 | This helps test case-insensitive searching.
373 | The quick brown fox jumps over the lazy dog.
374 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
375 | Short patterns like ab should also be findable.
376 | Single character patterns like 'a' appear frequently in this text.
377 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
378 | It contains multiple lines with various patterns.
379 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
380 | This helps test case-insensitive searching.
381 | The quick brown fox jumps over the lazy dog.
382 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
383 | Short patterns like ab should also be findable.
384 | Single character patterns like 'a' appear frequently in this text.
385 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
386 | It contains multiple lines with various patterns.
387 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
388 | This helps test case-insensitive searching.
389 | The quick brown fox jumps over the lazy dog.
390 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
391 | Short patterns like ab should also be findable.
392 | Single character patterns like 'a' appear frequently in this text.
393 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
394 | It contains multiple lines with various patterns.
395 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
396 | This helps test case-insensitive searching.
397 | The quick brown fox jumps over the lazy dog.
398 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
399 | Short patterns like ab should also be findable.
400 | Single character patterns like 'a' appear frequently in this text.
401 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
402 | It contains multiple lines with various patterns.
403 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
404 | This helps test case-insensitive searching.
405 | The quick brown fox jumps over the lazy dog.
406 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
407 | Short patterns like ab should also be findable.
408 | Single character patterns like 'a' appear frequently in this text.
409 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
410 | It contains multiple lines with various patterns.
411 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
412 | This helps test case-insensitive searching.
413 | The quick brown fox jumps over the lazy dog.
414 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
415 | Short patterns like ab should also be findable.
416 | Single character patterns like 'a' appear frequently in this text.
417 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
418 | It contains multiple lines with various patterns.
419 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
420 | This helps test case-insensitive searching.
421 | The quick brown fox jumps over the lazy dog.
422 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
423 | Short patterns like ab should also be findable.
424 | Single character patterns like 'a' appear frequently in this text.
425 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
426 | It contains multiple lines with various patterns.
427 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
428 | This helps test case-insensitive searching.
429 | The quick brown fox jumps over the lazy dog.
430 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
431 | Short patterns like ab should also be findable.
432 | Single character patterns like 'a' appear frequently in this text.
433 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
434 | It contains multiple lines with various patterns.
435 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
436 | This helps test case-insensitive searching.
437 | The quick brown fox jumps over the lazy dog.
438 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
439 | Short patterns like ab should also be findable.
440 | Single character patterns like 'a' appear frequently in this text.
441 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
442 | It contains multiple lines with various patterns.
443 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
444 | This helps test case-insensitive searching.
445 | The quick brown fox jumps over the lazy dog.
446 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
447 | Short patterns like ab should also be findable.
448 | Single character patterns like 'a' appear frequently in this text.
449 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
450 | It contains multiple lines with various patterns.
451 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
452 | This helps test case-insensitive searching.
453 | The quick brown fox jumps over the lazy dog.
454 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
455 | Short patterns like ab should also be findable.
456 | Single character patterns like 'a' appear frequently in this text.
457 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
458 | It contains multiple lines with various patterns.
459 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
460 | This helps test case-insensitive searching.
461 | The quick brown fox jumps over the lazy dog.
462 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
463 | Short patterns like ab should also be findable.
464 | Single character patterns like 'a' appear frequently in this text.
465 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
466 | It contains multiple lines with various patterns.
467 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
468 | This helps test case-insensitive searching.
469 | The quick brown fox jumps over the lazy dog.
470 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
471 | Short patterns like ab should also be findable.
472 | Single character patterns like 'a' appear frequently in this text.
473 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
474 | It contains multiple lines with various patterns.
475 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
476 | This helps test case-insensitive searching.
477 | The quick brown fox jumps over the lazy dog.
478 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
479 | Short patterns like ab should also be findable.
480 | Single character patterns like 'a' appear frequently in this text.
481 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
482 | It contains multiple lines with various patterns.
483 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
484 | This helps test case-insensitive searching.
485 | The quick brown fox jumps over the lazy dog.
486 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
487 | Short patterns like ab should also be findable.
488 | Single character patterns like 'a' appear frequently in this text.
489 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
490 | It contains multiple lines with various patterns.
491 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
492 | This helps test case-insensitive searching.
493 | The quick brown fox jumps over the lazy dog.
494 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
495 | Short patterns like ab should also be findable.
496 | Single character patterns like 'a' appear frequently in this text.
497 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
498 | It contains multiple lines with various patterns.
499 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
500 | This helps test case-insensitive searching.
501 | The quick brown fox jumps over the lazy dog.
502 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
503 | Short patterns like ab should also be findable.
504 | Single character patterns like 'a' appear frequently in this text.
505 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
506 | It contains multiple lines with various patterns.
507 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
508 | This helps test case-insensitive searching.
509 | The quick brown fox jumps over the lazy dog.
510 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
511 | Short patterns like ab should also be findable.
512 | Single character patterns like 'a' appear frequently in this text.
513 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
514 | It contains multiple lines with various patterns.
515 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
516 | This helps test case-insensitive searching.
517 | The quick brown fox jumps over the lazy dog.
518 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
519 | Short patterns like ab should also be findable.
520 | Single character patterns like 'a' appear frequently in this text.
521 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
522 | It contains multiple lines with various patterns.
523 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
524 | This helps test case-insensitive searching.
525 | The quick brown fox jumps over the lazy dog.
526 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
527 | Short patterns like ab should also be findable.
528 | Single character patterns like 'a' appear frequently in this text.
529 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
530 | It contains multiple lines with various patterns.
531 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
532 | This helps test case-insensitive searching.
533 | The quick brown fox jumps over the lazy dog.
534 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
535 | Short patterns like ab should also be findable.
536 | Single character patterns like 'a' appear frequently in this text.
537 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
538 | It contains multiple lines with various patterns.
539 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
540 | This helps test case-insensitive searching.
541 | The quick brown fox jumps over the lazy dog.
542 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
543 | Short patterns like ab should also be findable.
544 | Single character patterns like 'a' appear frequently in this text.
545 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
546 | It contains multiple lines with various patterns.
547 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
548 | This helps test case-insensitive searching.
549 | The quick brown fox jumps over the lazy dog.
550 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
551 | Short patterns like ab should also be findable.
552 | Single character patterns like 'a' appear frequently in this text.
553 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
554 | It contains multiple lines with various patterns.
555 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
556 | This helps test case-insensitive searching.
557 | The quick brown fox jumps over the lazy dog.
558 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
559 | Short patterns like ab should also be findable.
560 | Single character patterns like 'a' appear frequently in this text.
561 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
562 | It contains multiple lines with various patterns.
563 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
564 | This helps test case-insensitive searching.
565 | The quick brown fox jumps over the lazy dog.
566 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
567 | Short patterns like ab should also be findable.
568 | Single character patterns like 'a' appear frequently in this text.
569 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
570 | It contains multiple lines with various patterns.
571 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
572 | This helps test case-insensitive searching.
573 | The quick brown fox jumps over the lazy dog.
574 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
575 | Short patterns like ab should also be findable.
576 | Single character patterns like 'a' appear frequently in this text.
577 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
578 | It contains multiple lines with various patterns.
579 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
580 | This helps test case-insensitive searching.
581 | The quick brown fox jumps over the lazy dog.
582 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
583 | Short patterns like ab should also be findable.
584 | Single character patterns like 'a' appear frequently in this text.
585 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
586 | It contains multiple lines with various patterns.
587 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
588 | This helps test case-insensitive searching.
589 | The quick brown fox jumps over the lazy dog.
590 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
591 | Short patterns like ab should also be findable.
592 | Single character patterns like 'a' appear frequently in this text.
593 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
594 | It contains multiple lines with various patterns.
595 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
596 | This helps test case-insensitive searching.
597 | The quick brown fox jumps over the lazy dog.
598 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
599 | Short patterns like ab should also be findable.
600 | Single character patterns like 'a' appear frequently in this text.
601 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
602 | It contains multiple lines with various patterns.
603 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
604 | This helps test case-insensitive searching.
605 | The quick brown fox jumps over the lazy dog.
606 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
607 | Short patterns like ab should also be findable.
608 | Single character patterns like 'a' appear frequently in this text.
609 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
610 | It contains multiple lines with various patterns.
611 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
612 | This helps test case-insensitive searching.
613 | The quick brown fox jumps over the lazy dog.
614 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
615 | Short patterns like ab should also be findable.
616 | Single character patterns like 'a' appear frequently in this text.
617 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
618 | It contains multiple lines with various patterns.
619 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
620 | This helps test case-insensitive searching.
621 | The quick brown fox jumps over the lazy dog.
622 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
623 | Short patterns like ab should also be findable.
624 | Single character patterns like 'a' appear frequently in this text.
625 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
626 | It contains multiple lines with various patterns.
627 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
628 | This helps test case-insensitive searching.
629 | The quick brown fox jumps over the lazy dog.
630 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
631 | Short patterns like ab should also be findable.
632 | Single character patterns like 'a' appear frequently in this text.
633 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
634 | It contains multiple lines with various patterns.
635 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
636 | This helps test case-insensitive searching.
637 | The quick brown fox jumps over the lazy dog.
638 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
639 | Short patterns like ab should also be findable.
640 | Single character patterns like 'a' appear frequently in this text.
641 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
642 | It contains multiple lines with various patterns.
643 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
644 | This helps test case-insensitive searching.
645 | The quick brown fox jumps over the lazy dog.
646 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
647 | Short patterns like ab should also be findable.
648 | Single character patterns like 'a' appear frequently in this text.
649 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
650 | It contains multiple lines with various patterns.
651 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
652 | This helps test case-insensitive searching.
653 | The quick brown fox jumps over the lazy dog.
654 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
655 | Short patterns like ab should also be findable.
656 | Single character patterns like 'a' appear frequently in this text.
657 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
658 | It contains multiple lines with various patterns.
659 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
660 | This helps test case-insensitive searching.
661 | The quick brown fox jumps over the lazy dog.
662 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
663 | Short patterns like ab should also be findable.
664 | Single character patterns like 'a' appear frequently in this text.
665 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
666 | It contains multiple lines with various patterns.
667 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
668 | This helps test case-insensitive searching.
669 | The quick brown fox jumps over the lazy dog.
670 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
671 | Short patterns like ab should also be findable.
672 | Single character patterns like 'a' appear frequently in this text.
673 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
674 | It contains multiple lines with various patterns.
675 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
676 | This helps test case-insensitive searching.
677 | The quick brown fox jumps over the lazy dog.
678 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
679 | Short patterns like ab should also be findable.
680 | Single character patterns like 'a' appear frequently in this text.
681 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
682 | It contains multiple lines with various patterns.
683 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
684 | This helps test case-insensitive searching.
685 | The quick brown fox jumps over the lazy dog.
686 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
687 | Short patterns like ab should also be findable.
688 | Single character patterns like 'a' appear frequently in this text.
689 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
690 | It contains multiple lines with various patterns.
691 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
692 | This helps test case-insensitive searching.
693 | The quick brown fox jumps over the lazy dog.
694 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
695 | Short patterns like ab should also be findable.
696 | Single character patterns like 'a' appear frequently in this text.
697 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
698 | It contains multiple lines with various patterns.
699 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
700 | This helps test case-insensitive searching.
701 | The quick brown fox jumps over the lazy dog.
702 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
703 | Short patterns like ab should also be findable.
704 | Single character patterns like 'a' appear frequently in this text.
705 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
706 | It contains multiple lines with various patterns.
707 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
708 | This helps test case-insensitive searching.
709 | The quick brown fox jumps over the lazy dog.
710 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
711 | Short patterns like ab should also be findable.
712 | Single character patterns like 'a' appear frequently in this text.
713 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
714 | It contains multiple lines with various patterns.
715 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
716 | This helps test case-insensitive searching.
717 | The quick brown fox jumps over the lazy dog.
718 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
719 | Short patterns like ab should also be findable.
720 | Single character patterns like 'a' appear frequently in this text.
721 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
722 | It contains multiple lines with various patterns.
723 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
724 | This helps test case-insensitive searching.
725 | The quick brown fox jumps over the lazy dog.
726 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
727 | Short patterns like ab should also be findable.
728 | Single character patterns like 'a' appear frequently in this text.
729 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
730 | It contains multiple lines with various patterns.
731 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
732 | This helps test case-insensitive searching.
733 | The quick brown fox jumps over the lazy dog.
734 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
735 | Short patterns like ab should also be findable.
736 | Single character patterns like 'a' appear frequently in this text.
737 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
738 | It contains multiple lines with various patterns.
739 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
740 | This helps test case-insensitive searching.
741 | The quick brown fox jumps over the lazy dog.
742 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
743 | Short patterns like ab should also be findable.
744 | Single character patterns like 'a' appear frequently in this text.
745 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
746 | It contains multiple lines with various patterns.
747 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
748 | This helps test case-insensitive searching.
749 | The quick brown fox jumps over the lazy dog.
750 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
751 | Short patterns like ab should also be findable.
752 | Single character patterns like 'a' appear frequently in this text.
753 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
754 | It contains multiple lines with various patterns.
755 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
756 | This helps test case-insensitive searching.
757 | The quick brown fox jumps over the lazy dog.
758 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
759 | Short patterns like ab should also be findable.
760 | Single character patterns like 'a' appear frequently in this text.
761 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
762 | It contains multiple lines with various patterns.
763 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
764 | This helps test case-insensitive searching.
765 | The quick brown fox jumps over the lazy dog.
766 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
767 | Short patterns like ab should also be findable.
768 | Single character patterns like 'a' appear frequently in this text.
769 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
770 | It contains multiple lines with various patterns.
771 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
772 | This helps test case-insensitive searching.
773 | The quick brown fox jumps over the lazy dog.
774 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
775 | Short patterns like ab should also be findable.
776 | Single character patterns like 'a' appear frequently in this text.
777 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
778 | It contains multiple lines with various patterns.
779 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
780 | This helps test case-insensitive searching.
781 | The quick brown fox jumps over the lazy dog.
782 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
783 | Short patterns like ab should also be findable.
784 | Single character patterns like 'a' appear frequently in this text.
785 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
786 | It contains multiple lines with various patterns.
787 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
788 | This helps test case-insensitive searching.
789 | The quick brown fox jumps over the lazy dog.
790 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
791 | Short patterns like ab should also be findable.
792 | Single character patterns like 'a' appear frequently in this text.
793 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
794 | It contains multiple lines with various patterns.
795 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
796 | This helps test case-insensitive searching.
797 | The quick brown fox jumps over the lazy dog.
798 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
799 | Short patterns like ab should also be findable.
800 | Single character patterns like 'a' appear frequently in this text.
801 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
802 | It contains multiple lines with various patterns.
803 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
804 | This helps test case-insensitive searching.
805 | The quick brown fox jumps over the lazy dog.
806 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
807 | Short patterns like ab should also be findable.
808 | Single character patterns like 'a' appear frequently in this text.
809 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
810 | It contains multiple lines with various patterns.
811 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
812 | This helps test case-insensitive searching.
813 | The quick brown fox jumps over the lazy dog.
814 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
815 | Short patterns like ab should also be findable.
816 | Single character patterns like 'a' appear frequently in this text.
817 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
818 | It contains multiple lines with various patterns.
819 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
820 | This helps test case-insensitive searching.
821 | The quick brown fox jumps over the lazy dog.
822 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
823 | Short patterns like ab should also be findable.
824 | Single character patterns like 'a' appear frequently in this text.
825 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
826 | It contains multiple lines with various patterns.
827 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
828 | This helps test case-insensitive searching.
829 | The quick brown fox jumps over the lazy dog.
830 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
831 | Short patterns like ab should also be findable.
832 | Single character patterns like 'a' appear frequently in this text.
833 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
834 | It contains multiple lines with various patterns.
835 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
836 | This helps test case-insensitive searching.
837 | The quick brown fox jumps over the lazy dog.
838 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
839 | Short patterns like ab should also be findable.
840 | Single character patterns like 'a' appear frequently in this text.
841 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
842 | It contains multiple lines with various patterns.
843 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
844 | This helps test case-insensitive searching.
845 | The quick brown fox jumps over the lazy dog.
846 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
847 | Short patterns like ab should also be findable.
848 | Single character patterns like 'a' appear frequently in this text.
849 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
850 | It contains multiple lines with various patterns.
851 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
852 | This helps test case-insensitive searching.
853 | The quick brown fox jumps over the lazy dog.
854 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
855 | Short patterns like ab should also be findable.
856 | Single character patterns like 'a' appear frequently in this text.
857 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
858 | It contains multiple lines with various patterns.
859 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
860 | This helps test case-insensitive searching.
861 | The quick brown fox jumps over the lazy dog.
862 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
863 | Short patterns like ab should also be findable.
864 | Single character patterns like 'a' appear frequently in this text.
865 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
866 | It contains multiple lines with various patterns.
867 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
868 | This helps test case-insensitive searching.
869 | The quick brown fox jumps over the lazy dog.
870 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
871 | Short patterns like ab should also be findable.
872 | Single character patterns like 'a' appear frequently in this text.
873 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
874 | It contains multiple lines with various patterns.
875 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
876 | This helps test case-insensitive searching.
877 | The quick brown fox jumps over the lazy dog.
878 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
879 | Short patterns like ab should also be findable.
880 | Single character patterns like 'a' appear frequently in this text.
881 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
882 | It contains multiple lines with various patterns.
883 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
884 | This helps test case-insensitive searching.
885 | The quick brown fox jumps over the lazy dog.
886 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
887 | Short patterns like ab should also be findable.
888 | Single character patterns like 'a' appear frequently in this text.
889 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
890 | It contains multiple lines with various patterns.
891 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
892 | This helps test case-insensitive searching.
893 | The quick brown fox jumps over the lazy dog.
894 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
895 | Short patterns like ab should also be findable.
896 | Single character patterns like 'a' appear frequently in this text.
897 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
898 | It contains multiple lines with various patterns.
899 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
900 | This helps test case-insensitive searching.
901 | The quick brown fox jumps over the lazy dog.
902 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
903 | Short patterns like ab should also be findable.
904 | Single character patterns like 'a' appear frequently in this text.
905 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
906 | It contains multiple lines with various patterns.
907 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
908 | This helps test case-insensitive searching.
909 | The quick brown fox jumps over the lazy dog.
910 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
911 | Short patterns like ab should also be findable.
912 | Single character patterns like 'a' appear frequently in this text.
913 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
914 | It contains multiple lines with various patterns.
915 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
916 | This helps test case-insensitive searching.
917 | The quick brown fox jumps over the lazy dog.
918 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
919 | Short patterns like ab should also be findable.
920 | Single character patterns like 'a' appear frequently in this text.
921 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
922 | It contains multiple lines with various patterns.
923 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
924 | This helps test case-insensitive searching.
925 | The quick brown fox jumps over the lazy dog.
926 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
927 | Short patterns like ab should also be findable.
928 | Single character patterns like 'a' appear frequently in this text.
929 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
930 | It contains multiple lines with various patterns.
931 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
932 | This helps test case-insensitive searching.
933 | The quick brown fox jumps over the lazy dog.
934 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
935 | Short patterns like ab should also be findable.
936 | Single character patterns like 'a' appear frequently in this text.
937 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
938 | It contains multiple lines with various patterns.
939 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
940 | This helps test case-insensitive searching.
941 | The quick brown fox jumps over the lazy dog.
942 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
943 | Short patterns like ab should also be findable.
944 | Single character patterns like 'a' appear frequently in this text.
945 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
946 | It contains multiple lines with various patterns.
947 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
948 | This helps test case-insensitive searching.
949 | The quick brown fox jumps over the lazy dog.
950 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
951 | Short patterns like ab should also be findable.
952 | Single character patterns like 'a' appear frequently in this text.
953 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
954 | It contains multiple lines with various patterns.
955 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
956 | This helps test case-insensitive searching.
957 | The quick brown fox jumps over the lazy dog.
958 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
959 | Short patterns like ab should also be findable.
960 | Single character patterns like 'a' appear frequently in this text.
961 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
962 | It contains multiple lines with various patterns.
963 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
964 | This helps test case-insensitive searching.
965 | The quick brown fox jumps over the lazy dog.
966 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
967 | Short patterns like ab should also be findable.
968 | Single character patterns like 'a' appear frequently in this text.
969 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
970 | It contains multiple lines with various patterns.
971 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
972 | This helps test case-insensitive searching.
973 | The quick brown fox jumps over the lazy dog.
974 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
975 | Short patterns like ab should also be findable.
976 | Single character patterns like 'a' appear frequently in this text.
977 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
978 | It contains multiple lines with various patterns.
979 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
980 | This helps test case-insensitive searching.
981 | The quick brown fox jumps over the lazy dog.
982 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
983 | Short patterns like ab should also be findable.
984 | Single character patterns like 'a' appear frequently in this text.
985 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
986 | It contains multiple lines with various patterns.
987 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
988 | This helps test case-insensitive searching.
989 | The quick brown fox jumps over the lazy dog.
990 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
991 | Short patterns like ab should also be findable.
992 | Single character patterns like 'a' appear frequently in this text.
993 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
994 | It contains multiple lines with various patterns.
995 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
996 | This helps test case-insensitive searching.
997 | The quick brown fox jumps over the lazy dog.
998 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
999 | Short patterns like ab should also be findable.
1000 | Single character patterns like 'a' appear frequently in this text.
1001 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1002 | It contains multiple lines with various patterns.
1003 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1004 | This helps test case-insensitive searching.
1005 | The quick brown fox jumps over the lazy dog.
1006 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1007 | Short patterns like ab should also be findable.
1008 | Single character patterns like 'a' appear frequently in this text.
1009 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1010 | It contains multiple lines with various patterns.
1011 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1012 | This helps test case-insensitive searching.
1013 | The quick brown fox jumps over the lazy dog.
1014 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1015 | Short patterns like ab should also be findable.
1016 | Single character patterns like 'a' appear frequently in this text.
1017 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1018 | It contains multiple lines with various patterns.
1019 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1020 | This helps test case-insensitive searching.
1021 | The quick brown fox jumps over the lazy dog.
1022 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1023 | Short patterns like ab should also be findable.
1024 | Single character patterns like 'a' appear frequently in this text.
1025 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1026 | It contains multiple lines with various patterns.
1027 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1028 | This helps test case-insensitive searching.
1029 | The quick brown fox jumps over the lazy dog.
1030 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1031 | Short patterns like ab should also be findable.
1032 | Single character patterns like 'a' appear frequently in this text.
1033 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1034 | It contains multiple lines with various patterns.
1035 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1036 | This helps test case-insensitive searching.
1037 | The quick brown fox jumps over the lazy dog.
1038 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1039 | Short patterns like ab should also be findable.
1040 | Single character patterns like 'a' appear frequently in this text.
1041 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1042 | It contains multiple lines with various patterns.
1043 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1044 | This helps test case-insensitive searching.
1045 | The quick brown fox jumps over the lazy dog.
1046 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1047 | Short patterns like ab should also be findable.
1048 | Single character patterns like 'a' appear frequently in this text.
1049 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1050 | It contains multiple lines with various patterns.
1051 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1052 | This helps test case-insensitive searching.
1053 | The quick brown fox jumps over the lazy dog.
1054 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1055 | Short patterns like ab should also be findable.
1056 | Single character patterns like 'a' appear frequently in this text.
1057 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1058 | It contains multiple lines with various patterns.
1059 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1060 | This helps test case-insensitive searching.
1061 | The quick brown fox jumps over the lazy dog.
1062 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1063 | Short patterns like ab should also be findable.
1064 | Single character patterns like 'a' appear frequently in this text.
1065 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1066 | It contains multiple lines with various patterns.
1067 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1068 | This helps test case-insensitive searching.
1069 | The quick brown fox jumps over the lazy dog.
1070 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1071 | Short patterns like ab should also be findable.
1072 | Single character patterns like 'a' appear frequently in this text.
1073 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1074 | It contains multiple lines with various patterns.
1075 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1076 | This helps test case-insensitive searching.
1077 | The quick brown fox jumps over the lazy dog.
1078 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1079 | Short patterns like ab should also be findable.
1080 | Single character patterns like 'a' appear frequently in this text.
1081 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1082 | It contains multiple lines with various patterns.
1083 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1084 | This helps test case-insensitive searching.
1085 | The quick brown fox jumps over the lazy dog.
1086 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1087 | Short patterns like ab should also be findable.
1088 | Single character patterns like 'a' appear frequently in this text.
1089 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1090 | It contains multiple lines with various patterns.
1091 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1092 | This helps test case-insensitive searching.
1093 | The quick brown fox jumps over the lazy dog.
1094 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1095 | Short patterns like ab should also be findable.
1096 | Single character patterns like 'a' appear frequently in this text.
1097 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1098 | It contains multiple lines with various patterns.
1099 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1100 | This helps test case-insensitive searching.
1101 | The quick brown fox jumps over the lazy dog.
1102 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1103 | Short patterns like ab should also be findable.
1104 | Single character patterns like 'a' appear frequently in this text.
1105 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1106 | It contains multiple lines with various patterns.
1107 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1108 | This helps test case-insensitive searching.
1109 | The quick brown fox jumps over the lazy dog.
1110 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1111 | Short patterns like ab should also be findable.
1112 | Single character patterns like 'a' appear frequently in this text.
1113 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1114 | It contains multiple lines with various patterns.
1115 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1116 | This helps test case-insensitive searching.
1117 | The quick brown fox jumps over the lazy dog.
1118 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1119 | Short patterns like ab should also be findable.
1120 | Single character patterns like 'a' appear frequently in this text.
1121 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1122 | It contains multiple lines with various patterns.
1123 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1124 | This helps test case-insensitive searching.
1125 | The quick brown fox jumps over the lazy dog.
1126 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1127 | Short patterns like ab should also be findable.
1128 | Single character patterns like 'a' appear frequently in this text.
1129 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1130 | It contains multiple lines with various patterns.
1131 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1132 | This helps test case-insensitive searching.
1133 | The quick brown fox jumps over the lazy dog.
1134 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1135 | Short patterns like ab should also be findable.
1136 | Single character patterns like 'a' appear frequently in this text.
1137 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1138 | It contains multiple lines with various patterns.
1139 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1140 | This helps test case-insensitive searching.
1141 | The quick brown fox jumps over the lazy dog.
1142 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1143 | Short patterns like ab should also be findable.
1144 | Single character patterns like 'a' appear frequently in this text.
1145 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1146 | It contains multiple lines with various patterns.
1147 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1148 | This helps test case-insensitive searching.
1149 | The quick brown fox jumps over the lazy dog.
1150 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1151 | Short patterns like ab should also be findable.
1152 | Single character patterns like 'a' appear frequently in this text.
1153 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1154 | It contains multiple lines with various patterns.
1155 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1156 | This helps test case-insensitive searching.
1157 | The quick brown fox jumps over the lazy dog.
1158 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1159 | Short patterns like ab should also be findable.
1160 | Single character patterns like 'a' appear frequently in this text.
1161 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1162 | It contains multiple lines with various patterns.
1163 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1164 | This helps test case-insensitive searching.
1165 | The quick brown fox jumps over the lazy dog.
1166 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1167 | Short patterns like ab should also be findable.
1168 | Single character patterns like 'a' appear frequently in this text.
1169 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1170 | It contains multiple lines with various patterns.
1171 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1172 | This helps test case-insensitive searching.
1173 | The quick brown fox jumps over the lazy dog.
1174 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1175 | Short patterns like ab should also be findable.
1176 | Single character patterns like 'a' appear frequently in this text.
1177 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1178 | It contains multiple lines with various patterns.
1179 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1180 | This helps test case-insensitive searching.
1181 | The quick brown fox jumps over the lazy dog.
1182 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1183 | Short patterns like ab should also be findable.
1184 | Single character patterns like 'a' appear frequently in this text.
1185 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1186 | It contains multiple lines with various patterns.
1187 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1188 | This helps test case-insensitive searching.
1189 | The quick brown fox jumps over the lazy dog.
1190 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1191 | Short patterns like ab should also be findable.
1192 | Single character patterns like 'a' appear frequently in this text.
1193 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1194 | It contains multiple lines with various patterns.
1195 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1196 | This helps test case-insensitive searching.
1197 | The quick brown fox jumps over the lazy dog.
1198 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1199 | Short patterns like ab should also be findable.
1200 | Single character patterns like 'a' appear frequently in this text.
1201 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1202 | It contains multiple lines with various patterns.
1203 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1204 | This helps test case-insensitive searching.
1205 | The quick brown fox jumps over the lazy dog.
1206 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1207 | Short patterns like ab should also be findable.
1208 | Single character patterns like 'a' appear frequently in this text.
1209 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1210 | It contains multiple lines with various patterns.
1211 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1212 | This helps test case-insensitive searching.
1213 | The quick brown fox jumps over the lazy dog.
1214 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1215 | Short patterns like ab should also be findable.
1216 | Single character patterns like 'a' appear frequently in this text.
1217 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1218 | It contains multiple lines with various patterns.
1219 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1220 | This helps test case-insensitive searching.
1221 | The quick brown fox jumps over the lazy dog.
1222 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1223 | Short patterns like ab should also be findable.
1224 | Single character patterns like 'a' appear frequently in this text.
1225 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1226 | It contains multiple lines with various patterns.
1227 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1228 | This helps test case-insensitive searching.
1229 | The quick brown fox jumps over the lazy dog.
1230 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1231 | Short patterns like ab should also be findable.
1232 | Single character patterns like 'a' appear frequently in this text.
1233 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1234 | It contains multiple lines with various patterns.
1235 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1236 | This helps test case-insensitive searching.
1237 | The quick brown fox jumps over the lazy dog.
1238 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1239 | Short patterns like ab should also be findable.
1240 | Single character patterns like 'a' appear frequently in this text.
1241 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1242 | It contains multiple lines with various patterns.
1243 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1244 | This helps test case-insensitive searching.
1245 | The quick brown fox jumps over the lazy dog.
1246 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1247 | Short patterns like ab should also be findable.
1248 | Single character patterns like 'a' appear frequently in this text.
1249 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1250 | It contains multiple lines with various patterns.
1251 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1252 | This helps test case-insensitive searching.
1253 | The quick brown fox jumps over the lazy dog.
1254 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1255 | Short patterns like ab should also be findable.
1256 | Single character patterns like 'a' appear frequently in this text.
1257 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1258 | It contains multiple lines with various patterns.
1259 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1260 | This helps test case-insensitive searching.
1261 | The quick brown fox jumps over the lazy dog.
1262 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1263 | Short patterns like ab should also be findable.
1264 | Single character patterns like 'a' appear frequently in this text.
1265 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1266 | It contains multiple lines with various patterns.
1267 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1268 | This helps test case-insensitive searching.
1269 | The quick brown fox jumps over the lazy dog.
1270 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1271 | Short patterns like ab should also be findable.
1272 | Single character patterns like 'a' appear frequently in this text.
1273 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1274 | It contains multiple lines with various patterns.
1275 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1276 | This helps test case-insensitive searching.
1277 | The quick brown fox jumps over the lazy dog.
1278 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1279 | Short patterns like ab should also be findable.
1280 | Single character patterns like 'a' appear frequently in this text.
1281 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1282 | It contains multiple lines with various patterns.
1283 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1284 | This helps test case-insensitive searching.
1285 | The quick brown fox jumps over the lazy dog.
1286 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1287 | Short patterns like ab should also be findable.
1288 | Single character patterns like 'a' appear frequently in this text.
1289 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1290 | It contains multiple lines with various patterns.
1291 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1292 | This helps test case-insensitive searching.
1293 | The quick brown fox jumps over the lazy dog.
1294 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1295 | Short patterns like ab should also be findable.
1296 | Single character patterns like 'a' appear frequently in this text.
1297 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1298 | It contains multiple lines with various patterns.
1299 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1300 | This helps test case-insensitive searching.
1301 | The quick brown fox jumps over the lazy dog.
1302 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1303 | Short patterns like ab should also be findable.
1304 | Single character patterns like 'a' appear frequently in this text.
1305 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1306 | It contains multiple lines with various patterns.
1307 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1308 | This helps test case-insensitive searching.
1309 | The quick brown fox jumps over the lazy dog.
1310 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1311 | Short patterns like ab should also be findable.
1312 | Single character patterns like 'a' appear frequently in this text.
1313 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1314 | It contains multiple lines with various patterns.
1315 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1316 | This helps test case-insensitive searching.
1317 | The quick brown fox jumps over the lazy dog.
1318 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1319 | Short patterns like ab should also be findable.
1320 | Single character patterns like 'a' appear frequently in this text.
1321 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1322 | It contains multiple lines with various patterns.
1323 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1324 | This helps test case-insensitive searching.
1325 | The quick brown fox jumps over the lazy dog.
1326 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1327 | Short patterns like ab should also be findable.
1328 | Single character patterns like 'a' appear frequently in this text.
1329 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1330 | It contains multiple lines with various patterns.
1331 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1332 | This helps test case-insensitive searching.
1333 | The quick brown fox jumps over the lazy dog.
1334 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1335 | Short patterns like ab should also be findable.
1336 | Single character patterns like 'a' appear frequently in this text.
1337 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1338 | It contains multiple lines with various patterns.
1339 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1340 | This helps test case-insensitive searching.
1341 | The quick brown fox jumps over the lazy dog.
1342 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1343 | Short patterns like ab should also be findable.
1344 | Single character patterns like 'a' appear frequently in this text.
1345 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1346 | It contains multiple lines with various patterns.
1347 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1348 | This helps test case-insensitive searching.
1349 | The quick brown fox jumps over the lazy dog.
1350 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1351 | Short patterns like ab should also be findable.
1352 | Single character patterns like 'a' appear frequently in this text.
1353 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1354 | It contains multiple lines with various patterns.
1355 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1356 | This helps test case-insensitive searching.
1357 | The quick brown fox jumps over the lazy dog.
1358 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1359 | Short patterns like ab should also be findable.
1360 | Single character patterns like 'a' appear frequently in this text.
1361 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1362 | It contains multiple lines with various patterns.
1363 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1364 | This helps test case-insensitive searching.
1365 | The quick brown fox jumps over the lazy dog.
1366 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1367 | Short patterns like ab should also be findable.
1368 | Single character patterns like 'a' appear frequently in this text.
1369 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1370 | It contains multiple lines with various patterns.
1371 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1372 | This helps test case-insensitive searching.
1373 | The quick brown fox jumps over the lazy dog.
1374 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1375 | Short patterns like ab should also be findable.
1376 | Single character patterns like 'a' appear frequently in this text.
1377 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1378 | It contains multiple lines with various patterns.
1379 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1380 | This helps test case-insensitive searching.
1381 | The quick brown fox jumps over the lazy dog.
1382 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1383 | Short patterns like ab should also be findable.
1384 | Single character patterns like 'a' appear frequently in this text.
1385 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1386 | It contains multiple lines with various patterns.
1387 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1388 | This helps test case-insensitive searching.
1389 | The quick brown fox jumps over the lazy dog.
1390 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1391 | Short patterns like ab should also be findable.
1392 | Single character patterns like 'a' appear frequently in this text.
1393 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1394 | It contains multiple lines with various patterns.
1395 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1396 | This helps test case-insensitive searching.
1397 | The quick brown fox jumps over the lazy dog.
1398 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1399 | Short patterns like ab should also be findable.
1400 | Single character patterns like 'a' appear frequently in this text.
1401 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1402 | It contains multiple lines with various patterns.
1403 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1404 | This helps test case-insensitive searching.
1405 | The quick brown fox jumps over the lazy dog.
1406 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1407 | Short patterns like ab should also be findable.
1408 | Single character patterns like 'a' appear frequently in this text.
1409 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1410 | It contains multiple lines with various patterns.
1411 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1412 | This helps test case-insensitive searching.
1413 | The quick brown fox jumps over the lazy dog.
1414 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1415 | Short patterns like ab should also be findable.
1416 | Single character patterns like 'a' appear frequently in this text.
1417 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1418 | It contains multiple lines with various patterns.
1419 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1420 | This helps test case-insensitive searching.
1421 | The quick brown fox jumps over the lazy dog.
1422 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1423 | Short patterns like ab should also be findable.
1424 | Single character patterns like 'a' appear frequently in this text.
1425 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1426 | It contains multiple lines with various patterns.
1427 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1428 | This helps test case-insensitive searching.
1429 | The quick brown fox jumps over the lazy dog.
1430 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1431 | Short patterns like ab should also be findable.
1432 | Single character patterns like 'a' appear frequently in this text.
1433 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1434 | It contains multiple lines with various patterns.
1435 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1436 | This helps test case-insensitive searching.
1437 | The quick brown fox jumps over the lazy dog.
1438 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1439 | Short patterns like ab should also be findable.
1440 | Single character patterns like 'a' appear frequently in this text.
1441 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1442 | It contains multiple lines with various patterns.
1443 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1444 | This helps test case-insensitive searching.
1445 | The quick brown fox jumps over the lazy dog.
1446 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1447 | Short patterns like ab should also be findable.
1448 | Single character patterns like 'a' appear frequently in this text.
1449 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1450 | It contains multiple lines with various patterns.
1451 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1452 | This helps test case-insensitive searching.
1453 | The quick brown fox jumps over the lazy dog.
1454 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1455 | Short patterns like ab should also be findable.
1456 | Single character patterns like 'a' appear frequently in this text.
1457 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1458 | It contains multiple lines with various patterns.
1459 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1460 | This helps test case-insensitive searching.
1461 | The quick brown fox jumps over the lazy dog.
1462 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1463 | Short patterns like ab should also be findable.
1464 | Single character patterns like 'a' appear frequently in this text.
1465 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1466 | It contains multiple lines with various patterns.
1467 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1468 | This helps test case-insensitive searching.
1469 | The quick brown fox jumps over the lazy dog.
1470 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1471 | Short patterns like ab should also be findable.
1472 | Single character patterns like 'a' appear frequently in this text.
1473 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1474 | It contains multiple lines with various patterns.
1475 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1476 | This helps test case-insensitive searching.
1477 | The quick brown fox jumps over the lazy dog.
1478 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1479 | Short patterns like ab should also be findable.
1480 | Single character patterns like 'a' appear frequently in this text.
1481 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1482 | It contains multiple lines with various patterns.
1483 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1484 | This helps test case-insensitive searching.
1485 | The quick brown fox jumps over the lazy dog.
1486 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1487 | Short patterns like ab should also be findable.
1488 | Single character patterns like 'a' appear frequently in this text.
1489 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1490 | It contains multiple lines with various patterns.
1491 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1492 | This helps test case-insensitive searching.
1493 | The quick brown fox jumps over the lazy dog.
1494 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1495 | Short patterns like ab should also be findable.
1496 | Single character patterns like 'a' appear frequently in this text.
1497 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1498 | It contains multiple lines with various patterns.
1499 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1500 | This helps test case-insensitive searching.
1501 | The quick brown fox jumps over the lazy dog.
1502 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1503 | Short patterns like ab should also be findable.
1504 | Single character patterns like 'a' appear frequently in this text.
1505 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1506 | It contains multiple lines with various patterns.
1507 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1508 | This helps test case-insensitive searching.
1509 | The quick brown fox jumps over the lazy dog.
1510 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1511 | Short patterns like ab should also be findable.
1512 | Single character patterns like 'a' appear frequently in this text.
1513 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1514 | It contains multiple lines with various patterns.
1515 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1516 | This helps test case-insensitive searching.
1517 | The quick brown fox jumps over the lazy dog.
1518 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1519 | Short patterns like ab should also be findable.
1520 | Single character patterns like 'a' appear frequently in this text.
1521 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1522 | It contains multiple lines with various patterns.
1523 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1524 | This helps test case-insensitive searching.
1525 | The quick brown fox jumps over the lazy dog.
1526 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1527 | Short patterns like ab should also be findable.
1528 | Single character patterns like 'a' appear frequently in this text.
1529 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1530 | It contains multiple lines with various patterns.
1531 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1532 | This helps test case-insensitive searching.
1533 | The quick brown fox jumps over the lazy dog.
1534 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1535 | Short patterns like ab should also be findable.
1536 | Single character patterns like 'a' appear frequently in this text.
1537 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1538 | It contains multiple lines with various patterns.
1539 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1540 | This helps test case-insensitive searching.
1541 | The quick brown fox jumps over the lazy dog.
1542 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1543 | Short patterns like ab should also be findable.
1544 | Single character patterns like 'a' appear frequently in this text.
1545 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1546 | It contains multiple lines with various patterns.
1547 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1548 | This helps test case-insensitive searching.
1549 | The quick brown fox jumps over the lazy dog.
1550 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1551 | Short patterns like ab should also be findable.
1552 | Single character patterns like 'a' appear frequently in this text.
1553 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1554 | It contains multiple lines with various patterns.
1555 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1556 | This helps test case-insensitive searching.
1557 | The quick brown fox jumps over the lazy dog.
1558 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1559 | Short patterns like ab should also be findable.
1560 | Single character patterns like 'a' appear frequently in this text.
1561 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1562 | It contains multiple lines with various patterns.
1563 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1564 | This helps test case-insensitive searching.
1565 | The quick brown fox jumps over the lazy dog.
1566 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1567 | Short patterns like ab should also be findable.
1568 | Single character patterns like 'a' appear frequently in this text.
1569 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1570 | It contains multiple lines with various patterns.
1571 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1572 | This helps test case-insensitive searching.
1573 | The quick brown fox jumps over the lazy dog.
1574 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1575 | Short patterns like ab should also be findable.
1576 | Single character patterns like 'a' appear frequently in this text.
1577 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1578 | It contains multiple lines with various patterns.
1579 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1580 | This helps test case-insensitive searching.
1581 | The quick brown fox jumps over the lazy dog.
1582 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1583 | Short patterns like ab should also be findable.
1584 | Single character patterns like 'a' appear frequently in this text.
1585 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1586 | It contains multiple lines with various patterns.
1587 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1588 | This helps test case-insensitive searching.
1589 | The quick brown fox jumps over the lazy dog.
1590 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1591 | Short patterns like ab should also be findable.
1592 | Single character patterns like 'a' appear frequently in this text.
1593 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1594 | It contains multiple lines with various patterns.
1595 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1596 | This helps test case-insensitive searching.
1597 | The quick brown fox jumps over the lazy dog.
1598 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1599 | Short patterns like ab should also be findable.
1600 | Single character patterns like 'a' appear frequently in this text.
1601 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1602 | It contains multiple lines with various patterns.
1603 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1604 | This helps test case-insensitive searching.
1605 | The quick brown fox jumps over the lazy dog.
1606 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1607 | Short patterns like ab should also be findable.
1608 | Single character patterns like 'a' appear frequently in this text.
1609 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1610 | It contains multiple lines with various patterns.
1611 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1612 | This helps test case-insensitive searching.
1613 | The quick brown fox jumps over the lazy dog.
1614 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1615 | Short patterns like ab should also be findable.
1616 | Single character patterns like 'a' appear frequently in this text.
1617 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1618 | It contains multiple lines with various patterns.
1619 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1620 | This helps test case-insensitive searching.
1621 | The quick brown fox jumps over the lazy dog.
1622 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1623 | Short patterns like ab should also be findable.
1624 | Single character patterns like 'a' appear frequently in this text.
1625 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1626 | It contains multiple lines with various patterns.
1627 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1628 | This helps test case-insensitive searching.
1629 | The quick brown fox jumps over the lazy dog.
1630 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1631 | Short patterns like ab should also be findable.
1632 | Single character patterns like 'a' appear frequently in this text.
1633 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1634 | It contains multiple lines with various patterns.
1635 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1636 | This helps test case-insensitive searching.
1637 | The quick brown fox jumps over the lazy dog.
1638 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1639 | Short patterns like ab should also be findable.
1640 | Single character patterns like 'a' appear frequently in this text.
1641 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1642 | It contains multiple lines with various patterns.
1643 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1644 | This helps test case-insensitive searching.
1645 | The quick brown fox jumps over the lazy dog.
1646 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1647 | Short patterns like ab should also be findable.
1648 | Single character patterns like 'a' appear frequently in this text.
1649 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1650 | It contains multiple lines with various patterns.
1651 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1652 | This helps test case-insensitive searching.
1653 | The quick brown fox jumps over the lazy dog.
1654 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1655 | Short patterns like ab should also be findable.
1656 | Single character patterns like 'a' appear frequently in this text.
1657 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1658 | It contains multiple lines with various patterns.
1659 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1660 | This helps test case-insensitive searching.
1661 | The quick brown fox jumps over the lazy dog.
1662 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1663 | Short patterns like ab should also be findable.
1664 | Single character patterns like 'a' appear frequently in this text.
1665 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1666 | It contains multiple lines with various patterns.
1667 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1668 | This helps test case-insensitive searching.
1669 | The quick brown fox jumps over the lazy dog.
1670 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1671 | Short patterns like ab should also be findable.
1672 | Single character patterns like 'a' appear frequently in this text.
1673 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1674 | It contains multiple lines with various patterns.
1675 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1676 | This helps test case-insensitive searching.
1677 | The quick brown fox jumps over the lazy dog.
1678 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1679 | Short patterns like ab should also be findable.
1680 | Single character patterns like 'a' appear frequently in this text.
1681 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1682 | It contains multiple lines with various patterns.
1683 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1684 | This helps test case-insensitive searching.
1685 | The quick brown fox jumps over the lazy dog.
1686 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1687 | Short patterns like ab should also be findable.
1688 | Single character patterns like 'a' appear frequently in this text.
1689 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1690 | It contains multiple lines with various patterns.
1691 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1692 | This helps test case-insensitive searching.
1693 | The quick brown fox jumps over the lazy dog.
1694 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1695 | Short patterns like ab should also be findable.
1696 | Single character patterns like 'a' appear frequently in this text.
1697 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1698 | It contains multiple lines with various patterns.
1699 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1700 | This helps test case-insensitive searching.
1701 | The quick brown fox jumps over the lazy dog.
1702 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1703 | Short patterns like ab should also be findable.
1704 | Single character patterns like 'a' appear frequently in this text.
1705 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1706 | It contains multiple lines with various patterns.
1707 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1708 | This helps test case-insensitive searching.
1709 | The quick brown fox jumps over the lazy dog.
1710 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1711 | Short patterns like ab should also be findable.
1712 | Single character patterns like 'a' appear frequently in this text.
1713 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1714 | It contains multiple lines with various patterns.
1715 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1716 | This helps test case-insensitive searching.
1717 | The quick brown fox jumps over the lazy dog.
1718 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1719 | Short patterns like ab should also be findable.
1720 | Single character patterns like 'a' appear frequently in this text.
1721 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1722 | It contains multiple lines with various patterns.
1723 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1724 | This helps test case-insensitive searching.
1725 | The quick brown fox jumps over the lazy dog.
1726 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1727 | Short patterns like ab should also be findable.
1728 | Single character patterns like 'a' appear frequently in this text.
1729 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1730 | It contains multiple lines with various patterns.
1731 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1732 | This helps test case-insensitive searching.
1733 | The quick brown fox jumps over the lazy dog.
1734 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1735 | Short patterns like ab should also be findable.
1736 | Single character patterns like 'a' appear frequently in this text.
1737 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1738 | It contains multiple lines with various patterns.
1739 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1740 | This helps test case-insensitive searching.
1741 | The quick brown fox jumps over the lazy dog.
1742 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1743 | Short patterns like ab should also be findable.
1744 | Single character patterns like 'a' appear frequently in this text.
1745 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1746 | It contains multiple lines with various patterns.
1747 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1748 | This helps test case-insensitive searching.
1749 | The quick brown fox jumps over the lazy dog.
1750 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1751 | Short patterns like ab should also be findable.
1752 | Single character patterns like 'a' appear frequently in this text.
1753 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1754 | It contains multiple lines with various patterns.
1755 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1756 | This helps test case-insensitive searching.
1757 | The quick brown fox jumps over the lazy dog.
1758 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1759 | Short patterns like ab should also be findable.
1760 | Single character patterns like 'a' appear frequently in this text.
1761 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1762 | It contains multiple lines with various patterns.
1763 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1764 | This helps test case-insensitive searching.
1765 | The quick brown fox jumps over the lazy dog.
1766 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1767 | Short patterns like ab should also be findable.
1768 | Single character patterns like 'a' appear frequently in this text.
1769 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1770 | It contains multiple lines with various patterns.
1771 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1772 | This helps test case-insensitive searching.
1773 | The quick brown fox jumps over the lazy dog.
1774 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1775 | Short patterns like ab should also be findable.
1776 | Single character patterns like 'a' appear frequently in this text.
1777 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1778 | It contains multiple lines with various patterns.
1779 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1780 | This helps test case-insensitive searching.
1781 | The quick brown fox jumps over the lazy dog.
1782 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1783 | Short patterns like ab should also be findable.
1784 | Single character patterns like 'a' appear frequently in this text.
1785 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1786 | It contains multiple lines with various patterns.
1787 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1788 | This helps test case-insensitive searching.
1789 | The quick brown fox jumps over the lazy dog.
1790 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1791 | Short patterns like ab should also be findable.
1792 | Single character patterns like 'a' appear frequently in this text.
1793 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1794 | It contains multiple lines with various patterns.
1795 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1796 | This helps test case-insensitive searching.
1797 | The quick brown fox jumps over the lazy dog.
1798 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1799 | Short patterns like ab should also be findable.
1800 | Single character patterns like 'a' appear frequently in this text.
1801 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1802 | It contains multiple lines with various patterns.
1803 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1804 | This helps test case-insensitive searching.
1805 | The quick brown fox jumps over the lazy dog.
1806 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1807 | Short patterns like ab should also be findable.
1808 | Single character patterns like 'a' appear frequently in this text.
1809 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1810 | It contains multiple lines with various patterns.
1811 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1812 | This helps test case-insensitive searching.
1813 | The quick brown fox jumps over the lazy dog.
1814 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1815 | Short patterns like ab should also be findable.
1816 | Single character patterns like 'a' appear frequently in this text.
1817 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1818 | It contains multiple lines with various patterns.
1819 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1820 | This helps test case-insensitive searching.
1821 | The quick brown fox jumps over the lazy dog.
1822 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1823 | Short patterns like ab should also be findable.
1824 | Single character patterns like 'a' appear frequently in this text.
1825 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1826 | It contains multiple lines with various patterns.
1827 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1828 | This helps test case-insensitive searching.
1829 | The quick brown fox jumps over the lazy dog.
1830 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1831 | Short patterns like ab should also be findable.
1832 | Single character patterns like 'a' appear frequently in this text.
1833 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1834 | It contains multiple lines with various patterns.
1835 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1836 | This helps test case-insensitive searching.
1837 | The quick brown fox jumps over the lazy dog.
1838 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1839 | Short patterns like ab should also be findable.
1840 | Single character patterns like 'a' appear frequently in this text.
1841 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1842 | It contains multiple lines with various patterns.
1843 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1844 | This helps test case-insensitive searching.
1845 | The quick brown fox jumps over the lazy dog.
1846 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1847 | Short patterns like ab should also be findable.
1848 | Single character patterns like 'a' appear frequently in this text.
1849 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1850 | It contains multiple lines with various patterns.
1851 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1852 | This helps test case-insensitive searching.
1853 | The quick brown fox jumps over the lazy dog.
1854 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1855 | Short patterns like ab should also be findable.
1856 | Single character patterns like 'a' appear frequently in this text.
1857 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1858 | It contains multiple lines with various patterns.
1859 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1860 | This helps test case-insensitive searching.
1861 | The quick brown fox jumps over the lazy dog.
1862 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1863 | Short patterns like ab should also be findable.
1864 | Single character patterns like 'a' appear frequently in this text.
1865 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1866 | It contains multiple lines with various patterns.
1867 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1868 | This helps test case-insensitive searching.
1869 | The quick brown fox jumps over the lazy dog.
1870 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1871 | Short patterns like ab should also be findable.
1872 | Single character patterns like 'a' appear frequently in this text.
1873 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1874 | It contains multiple lines with various patterns.
1875 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1876 | This helps test case-insensitive searching.
1877 | The quick brown fox jumps over the lazy dog.
1878 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1879 | Short patterns like ab should also be findable.
1880 | Single character patterns like 'a' appear frequently in this text.
1881 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1882 | It contains multiple lines with various patterns.
1883 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1884 | This helps test case-insensitive searching.
1885 | The quick brown fox jumps over the lazy dog.
1886 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1887 | Short patterns like ab should also be findable.
1888 | Single character patterns like 'a' appear frequently in this text.
1889 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1890 | It contains multiple lines with various patterns.
1891 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1892 | This helps test case-insensitive searching.
1893 | The quick brown fox jumps over the lazy dog.
1894 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1895 | Short patterns like ab should also be findable.
1896 | Single character patterns like 'a' appear frequently in this text.
1897 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1898 | It contains multiple lines with various patterns.
1899 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1900 | This helps test case-insensitive searching.
1901 | The quick brown fox jumps over the lazy dog.
1902 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1903 | Short patterns like ab should also be findable.
1904 | Single character patterns like 'a' appear frequently in this text.
1905 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1906 | It contains multiple lines with various patterns.
1907 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1908 | This helps test case-insensitive searching.
1909 | The quick brown fox jumps over the lazy dog.
1910 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1911 | Short patterns like ab should also be findable.
1912 | Single character patterns like 'a' appear frequently in this text.
1913 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1914 | It contains multiple lines with various patterns.
1915 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1916 | This helps test case-insensitive searching.
1917 | The quick brown fox jumps over the lazy dog.
1918 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1919 | Short patterns like ab should also be findable.
1920 | Single character patterns like 'a' appear frequently in this text.
1921 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1922 | It contains multiple lines with various patterns.
1923 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1924 | This helps test case-insensitive searching.
1925 | The quick brown fox jumps over the lazy dog.
1926 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1927 | Short patterns like ab should also be findable.
1928 | Single character patterns like 'a' appear frequently in this text.
1929 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1930 | It contains multiple lines with various patterns.
1931 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1932 | This helps test case-insensitive searching.
1933 | The quick brown fox jumps over the lazy dog.
1934 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1935 | Short patterns like ab should also be findable.
1936 | Single character patterns like 'a' appear frequently in this text.
1937 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1938 | It contains multiple lines with various patterns.
1939 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1940 | This helps test case-insensitive searching.
1941 | The quick brown fox jumps over the lazy dog.
1942 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1943 | Short patterns like ab should also be findable.
1944 | Single character patterns like 'a' appear frequently in this text.
1945 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1946 | It contains multiple lines with various patterns.
1947 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1948 | This helps test case-insensitive searching.
1949 | The quick brown fox jumps over the lazy dog.
1950 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1951 | Short patterns like ab should also be findable.
1952 | Single character patterns like 'a' appear frequently in this text.
1953 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1954 | It contains multiple lines with various patterns.
1955 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1956 | This helps test case-insensitive searching.
1957 | The quick brown fox jumps over the lazy dog.
1958 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1959 | Short patterns like ab should also be findable.
1960 | Single character patterns like 'a' appear frequently in this text.
1961 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1962 | It contains multiple lines with various patterns.
1963 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1964 | This helps test case-insensitive searching.
1965 | The quick brown fox jumps over the lazy dog.
1966 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1967 | Short patterns like ab should also be findable.
1968 | Single character patterns like 'a' appear frequently in this text.
1969 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1970 | It contains multiple lines with various patterns.
1971 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1972 | This helps test case-insensitive searching.
1973 | The quick brown fox jumps over the lazy dog.
1974 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1975 | Short patterns like ab should also be findable.
1976 | Single character patterns like 'a' appear frequently in this text.
1977 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1978 | It contains multiple lines with various patterns.
1979 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1980 | This helps test case-insensitive searching.
1981 | The quick brown fox jumps over the lazy dog.
1982 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1983 | Short patterns like ab should also be findable.
1984 | Single character patterns like 'a' appear frequently in this text.
1985 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1986 | It contains multiple lines with various patterns.
1987 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1988 | This helps test case-insensitive searching.
1989 | The quick brown fox jumps over the lazy dog.
1990 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1991 | Short patterns like ab should also be findable.
1992 | Single character patterns like 'a' appear frequently in this text.
1993 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
1994 | It contains multiple lines with various patterns.
1995 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
1996 | This helps test case-insensitive searching.
1997 | The quick brown fox jumps over the lazy dog.
1998 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
1999 | Short patterns like ab should also be findable.
2000 | Single character patterns like 'a' appear frequently in this text.
2001 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2002 | It contains multiple lines with various patterns.
2003 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2004 | This helps test case-insensitive searching.
2005 | The quick brown fox jumps over the lazy dog.
2006 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2007 | Short patterns like ab should also be findable.
2008 | Single character patterns like 'a' appear frequently in this text.
2009 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2010 | It contains multiple lines with various patterns.
2011 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2012 | This helps test case-insensitive searching.
2013 | The quick brown fox jumps over the lazy dog.
2014 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2015 | Short patterns like ab should also be findable.
2016 | Single character patterns like 'a' appear frequently in this text.
2017 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2018 | It contains multiple lines with various patterns.
2019 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2020 | This helps test case-insensitive searching.
2021 | The quick brown fox jumps over the lazy dog.
2022 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2023 | Short patterns like ab should also be findable.
2024 | Single character patterns like 'a' appear frequently in this text.
2025 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2026 | It contains multiple lines with various patterns.
2027 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2028 | This helps test case-insensitive searching.
2029 | The quick brown fox jumps over the lazy dog.
2030 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2031 | Short patterns like ab should also be findable.
2032 | Single character patterns like 'a' appear frequently in this text.
2033 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2034 | It contains multiple lines with various patterns.
2035 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2036 | This helps test case-insensitive searching.
2037 | The quick brown fox jumps over the lazy dog.
2038 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2039 | Short patterns like ab should also be findable.
2040 | Single character patterns like 'a' appear frequently in this text.
2041 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2042 | It contains multiple lines with various patterns.
2043 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2044 | This helps test case-insensitive searching.
2045 | The quick brown fox jumps over the lazy dog.
2046 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2047 | Short patterns like ab should also be findable.
2048 | Single character patterns like 'a' appear frequently in this text.
2049 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2050 | It contains multiple lines with various patterns.
2051 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2052 | This helps test case-insensitive searching.
2053 | The quick brown fox jumps over the lazy dog.
2054 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2055 | Short patterns like ab should also be findable.
2056 | Single character patterns like 'a' appear frequently in this text.
2057 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2058 | It contains multiple lines with various patterns.
2059 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2060 | This helps test case-insensitive searching.
2061 | The quick brown fox jumps over the lazy dog.
2062 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2063 | Short patterns like ab should also be findable.
2064 | Single character patterns like 'a' appear frequently in this text.
2065 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2066 | It contains multiple lines with various patterns.
2067 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2068 | This helps test case-insensitive searching.
2069 | The quick brown fox jumps over the lazy dog.
2070 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2071 | Short patterns like ab should also be findable.
2072 | Single character patterns like 'a' appear frequently in this text.
2073 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2074 | It contains multiple lines with various patterns.
2075 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2076 | This helps test case-insensitive searching.
2077 | The quick brown fox jumps over the lazy dog.
2078 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2079 | Short patterns like ab should also be findable.
2080 | Single character patterns like 'a' appear frequently in this text.
2081 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2082 | It contains multiple lines with various patterns.
2083 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2084 | This helps test case-insensitive searching.
2085 | The quick brown fox jumps over the lazy dog.
2086 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2087 | Short patterns like ab should also be findable.
2088 | Single character patterns like 'a' appear frequently in this text.
2089 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2090 | It contains multiple lines with various patterns.
2091 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2092 | This helps test case-insensitive searching.
2093 | The quick brown fox jumps over the lazy dog.
2094 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2095 | Short patterns like ab should also be findable.
2096 | Single character patterns like 'a' appear frequently in this text.
2097 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2098 | It contains multiple lines with various patterns.
2099 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2100 | This helps test case-insensitive searching.
2101 | The quick brown fox jumps over the lazy dog.
2102 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2103 | Short patterns like ab should also be findable.
2104 | Single character patterns like 'a' appear frequently in this text.
2105 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2106 | It contains multiple lines with various patterns.
2107 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2108 | This helps test case-insensitive searching.
2109 | The quick brown fox jumps over the lazy dog.
2110 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2111 | Short patterns like ab should also be findable.
2112 | Single character patterns like 'a' appear frequently in this text.
2113 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2114 | It contains multiple lines with various patterns.
2115 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2116 | This helps test case-insensitive searching.
2117 | The quick brown fox jumps over the lazy dog.
2118 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2119 | Short patterns like ab should also be findable.
2120 | Single character patterns like 'a' appear frequently in this text.
2121 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2122 | It contains multiple lines with various patterns.
2123 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2124 | This helps test case-insensitive searching.
2125 | The quick brown fox jumps over the lazy dog.
2126 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2127 | Short patterns like ab should also be findable.
2128 | Single character patterns like 'a' appear frequently in this text.
2129 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2130 | It contains multiple lines with various patterns.
2131 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2132 | This helps test case-insensitive searching.
2133 | The quick brown fox jumps over the lazy dog.
2134 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2135 | Short patterns like ab should also be findable.
2136 | Single character patterns like 'a' appear frequently in this text.
2137 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2138 | It contains multiple lines with various patterns.
2139 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2140 | This helps test case-insensitive searching.
2141 | The quick brown fox jumps over the lazy dog.
2142 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2143 | Short patterns like ab should also be findable.
2144 | Single character patterns like 'a' appear frequently in this text.
2145 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2146 | It contains multiple lines with various patterns.
2147 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2148 | This helps test case-insensitive searching.
2149 | The quick brown fox jumps over the lazy dog.
2150 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2151 | Short patterns like ab should also be findable.
2152 | Single character patterns like 'a' appear frequently in this text.
2153 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2154 | It contains multiple lines with various patterns.
2155 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2156 | This helps test case-insensitive searching.
2157 | The quick brown fox jumps over the lazy dog.
2158 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2159 | Short patterns like ab should also be findable.
2160 | Single character patterns like 'a' appear frequently in this text.
2161 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2162 | It contains multiple lines with various patterns.
2163 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2164 | This helps test case-insensitive searching.
2165 | The quick brown fox jumps over the lazy dog.
2166 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2167 | Short patterns like ab should also be findable.
2168 | Single character patterns like 'a' appear frequently in this text.
2169 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2170 | It contains multiple lines with various patterns.
2171 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2172 | This helps test case-insensitive searching.
2173 | The quick brown fox jumps over the lazy dog.
2174 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2175 | Short patterns like ab should also be findable.
2176 | Single character patterns like 'a' appear frequently in this text.
2177 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2178 | It contains multiple lines with various patterns.
2179 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2180 | This helps test case-insensitive searching.
2181 | The quick brown fox jumps over the lazy dog.
2182 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2183 | Short patterns like ab should also be findable.
2184 | Single character patterns like 'a' appear frequently in this text.
2185 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2186 | It contains multiple lines with various patterns.
2187 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2188 | This helps test case-insensitive searching.
2189 | The quick brown fox jumps over the lazy dog.
2190 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2191 | Short patterns like ab should also be findable.
2192 | Single character patterns like 'a' appear frequently in this text.
2193 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2194 | It contains multiple lines with various patterns.
2195 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2196 | This helps test case-insensitive searching.
2197 | The quick brown fox jumps over the lazy dog.
2198 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2199 | Short patterns like ab should also be findable.
2200 | Single character patterns like 'a' appear frequently in this text.
2201 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2202 | It contains multiple lines with various patterns.
2203 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2204 | This helps test case-insensitive searching.
2205 | The quick brown fox jumps over the lazy dog.
2206 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2207 | Short patterns like ab should also be findable.
2208 | Single character patterns like 'a' appear frequently in this text.
2209 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2210 | It contains multiple lines with various patterns.
2211 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2212 | This helps test case-insensitive searching.
2213 | The quick brown fox jumps over the lazy dog.
2214 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2215 | Short patterns like ab should also be findable.
2216 | Single character patterns like 'a' appear frequently in this text.
2217 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2218 | It contains multiple lines with various patterns.
2219 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2220 | This helps test case-insensitive searching.
2221 | The quick brown fox jumps over the lazy dog.
2222 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2223 | Short patterns like ab should also be findable.
2224 | Single character patterns like 'a' appear frequently in this text.
2225 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2226 | It contains multiple lines with various patterns.
2227 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2228 | This helps test case-insensitive searching.
2229 | The quick brown fox jumps over the lazy dog.
2230 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2231 | Short patterns like ab should also be findable.
2232 | Single character patterns like 'a' appear frequently in this text.
2233 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2234 | It contains multiple lines with various patterns.
2235 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2236 | This helps test case-insensitive searching.
2237 | The quick brown fox jumps over the lazy dog.
2238 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2239 | Short patterns like ab should also be findable.
2240 | Single character patterns like 'a' appear frequently in this text.
2241 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2242 | It contains multiple lines with various patterns.
2243 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2244 | This helps test case-insensitive searching.
2245 | The quick brown fox jumps over the lazy dog.
2246 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2247 | Short patterns like ab should also be findable.
2248 | Single character patterns like 'a' appear frequently in this text.
2249 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2250 | It contains multiple lines with various patterns.
2251 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2252 | This helps test case-insensitive searching.
2253 | The quick brown fox jumps over the lazy dog.
2254 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2255 | Short patterns like ab should also be findable.
2256 | Single character patterns like 'a' appear frequently in this text.
2257 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2258 | It contains multiple lines with various patterns.
2259 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2260 | This helps test case-insensitive searching.
2261 | The quick brown fox jumps over the lazy dog.
2262 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2263 | Short patterns like ab should also be findable.
2264 | Single character patterns like 'a' appear frequently in this text.
2265 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2266 | It contains multiple lines with various patterns.
2267 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2268 | This helps test case-insensitive searching.
2269 | The quick brown fox jumps over the lazy dog.
2270 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2271 | Short patterns like ab should also be findable.
2272 | Single character patterns like 'a' appear frequently in this text.
2273 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2274 | It contains multiple lines with various patterns.
2275 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2276 | This helps test case-insensitive searching.
2277 | The quick brown fox jumps over the lazy dog.
2278 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2279 | Short patterns like ab should also be findable.
2280 | Single character patterns like 'a' appear frequently in this text.
2281 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2282 | It contains multiple lines with various patterns.
2283 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2284 | This helps test case-insensitive searching.
2285 | The quick brown fox jumps over the lazy dog.
2286 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2287 | Short patterns like ab should also be findable.
2288 | Single character patterns like 'a' appear frequently in this text.
2289 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2290 | It contains multiple lines with various patterns.
2291 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2292 | This helps test case-insensitive searching.
2293 | The quick brown fox jumps over the lazy dog.
2294 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2295 | Short patterns like ab should also be findable.
2296 | Single character patterns like 'a' appear frequently in this text.
2297 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2298 | It contains multiple lines with various patterns.
2299 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2300 | This helps test case-insensitive searching.
2301 | The quick brown fox jumps over the lazy dog.
2302 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2303 | Short patterns like ab should also be findable.
2304 | Single character patterns like 'a' appear frequently in this text.
2305 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2306 | It contains multiple lines with various patterns.
2307 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2308 | This helps test case-insensitive searching.
2309 | The quick brown fox jumps over the lazy dog.
2310 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2311 | Short patterns like ab should also be findable.
2312 | Single character patterns like 'a' appear frequently in this text.
2313 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2314 | It contains multiple lines with various patterns.
2315 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2316 | This helps test case-insensitive searching.
2317 | The quick brown fox jumps over the lazy dog.
2318 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2319 | Short patterns like ab should also be findable.
2320 | Single character patterns like 'a' appear frequently in this text.
2321 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2322 | It contains multiple lines with various patterns.
2323 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2324 | This helps test case-insensitive searching.
2325 | The quick brown fox jumps over the lazy dog.
2326 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2327 | Short patterns like ab should also be findable.
2328 | Single character patterns like 'a' appear frequently in this text.
2329 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2330 | It contains multiple lines with various patterns.
2331 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2332 | This helps test case-insensitive searching.
2333 | The quick brown fox jumps over the lazy dog.
2334 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2335 | Short patterns like ab should also be findable.
2336 | Single character patterns like 'a' appear frequently in this text.
2337 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2338 | It contains multiple lines with various patterns.
2339 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2340 | This helps test case-insensitive searching.
2341 | The quick brown fox jumps over the lazy dog.
2342 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2343 | Short patterns like ab should also be findable.
2344 | Single character patterns like 'a' appear frequently in this text.
2345 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2346 | It contains multiple lines with various patterns.
2347 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2348 | This helps test case-insensitive searching.
2349 | The quick brown fox jumps over the lazy dog.
2350 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2351 | Short patterns like ab should also be findable.
2352 | Single character patterns like 'a' appear frequently in this text.
2353 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2354 | It contains multiple lines with various patterns.
2355 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2356 | This helps test case-insensitive searching.
2357 | The quick brown fox jumps over the lazy dog.
2358 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2359 | Short patterns like ab should also be findable.
2360 | Single character patterns like 'a' appear frequently in this text.
2361 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2362 | It contains multiple lines with various patterns.
2363 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2364 | This helps test case-insensitive searching.
2365 | The quick brown fox jumps over the lazy dog.
2366 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2367 | Short patterns like ab should also be findable.
2368 | Single character patterns like 'a' appear frequently in this text.
2369 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2370 | It contains multiple lines with various patterns.
2371 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2372 | This helps test case-insensitive searching.
2373 | The quick brown fox jumps over the lazy dog.
2374 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2375 | Short patterns like ab should also be findable.
2376 | Single character patterns like 'a' appear frequently in this text.
2377 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2378 | It contains multiple lines with various patterns.
2379 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2380 | This helps test case-insensitive searching.
2381 | The quick brown fox jumps over the lazy dog.
2382 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2383 | Short patterns like ab should also be findable.
2384 | Single character patterns like 'a' appear frequently in this text.
2385 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2386 | It contains multiple lines with various patterns.
2387 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2388 | This helps test case-insensitive searching.
2389 | The quick brown fox jumps over the lazy dog.
2390 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2391 | Short patterns like ab should also be findable.
2392 | Single character patterns like 'a' appear frequently in this text.
2393 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2394 | It contains multiple lines with various patterns.
2395 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2396 | This helps test case-insensitive searching.
2397 | The quick brown fox jumps over the lazy dog.
2398 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2399 | Short patterns like ab should also be findable.
2400 | Single character patterns like 'a' appear frequently in this text.
2401 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2402 | It contains multiple lines with various patterns.
2403 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2404 | This helps test case-insensitive searching.
2405 | The quick brown fox jumps over the lazy dog.
2406 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2407 | Short patterns like ab should also be findable.
2408 | Single character patterns like 'a' appear frequently in this text.
2409 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2410 | It contains multiple lines with various patterns.
2411 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2412 | This helps test case-insensitive searching.
2413 | The quick brown fox jumps over the lazy dog.
2414 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2415 | Short patterns like ab should also be findable.
2416 | Single character patterns like 'a' appear frequently in this text.
2417 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2418 | It contains multiple lines with various patterns.
2419 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2420 | This helps test case-insensitive searching.
2421 | The quick brown fox jumps over the lazy dog.
2422 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2423 | Short patterns like ab should also be findable.
2424 | Single character patterns like 'a' appear frequently in this text.
2425 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2426 | It contains multiple lines with various patterns.
2427 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2428 | This helps test case-insensitive searching.
2429 | The quick brown fox jumps over the lazy dog.
2430 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2431 | Short patterns like ab should also be findable.
2432 | Single character patterns like 'a' appear frequently in this text.
2433 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2434 | It contains multiple lines with various patterns.
2435 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2436 | This helps test case-insensitive searching.
2437 | The quick brown fox jumps over the lazy dog.
2438 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2439 | Short patterns like ab should also be findable.
2440 | Single character patterns like 'a' appear frequently in this text.
2441 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2442 | It contains multiple lines with various patterns.
2443 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2444 | This helps test case-insensitive searching.
2445 | The quick brown fox jumps over the lazy dog.
2446 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2447 | Short patterns like ab should also be findable.
2448 | Single character patterns like 'a' appear frequently in this text.
2449 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2450 | It contains multiple lines with various patterns.
2451 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2452 | This helps test case-insensitive searching.
2453 | The quick brown fox jumps over the lazy dog.
2454 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2455 | Short patterns like ab should also be findable.
2456 | Single character patterns like 'a' appear frequently in this text.
2457 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2458 | It contains multiple lines with various patterns.
2459 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2460 | This helps test case-insensitive searching.
2461 | The quick brown fox jumps over the lazy dog.
2462 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2463 | Short patterns like ab should also be findable.
2464 | Single character patterns like 'a' appear frequently in this text.
2465 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2466 | It contains multiple lines with various patterns.
2467 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2468 | This helps test case-insensitive searching.
2469 | The quick brown fox jumps over the lazy dog.
2470 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2471 | Short patterns like ab should also be findable.
2472 | Single character patterns like 'a' appear frequently in this text.
2473 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2474 | It contains multiple lines with various patterns.
2475 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2476 | This helps test case-insensitive searching.
2477 | The quick brown fox jumps over the lazy dog.
2478 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2479 | Short patterns like ab should also be findable.
2480 | Single character patterns like 'a' appear frequently in this text.
2481 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2482 | It contains multiple lines with various patterns.
2483 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2484 | This helps test case-insensitive searching.
2485 | The quick brown fox jumps over the lazy dog.
2486 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2487 | Short patterns like ab should also be findable.
2488 | Single character patterns like 'a' appear frequently in this text.
2489 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2490 | It contains multiple lines with various patterns.
2491 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2492 | This helps test case-insensitive searching.
2493 | The quick brown fox jumps over the lazy dog.
2494 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2495 | Short patterns like ab should also be findable.
2496 | Single character patterns like 'a' appear frequently in this text.
2497 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2498 | It contains multiple lines with various patterns.
2499 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2500 | This helps test case-insensitive searching.
2501 | The quick brown fox jumps over the lazy dog.
2502 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2503 | Short patterns like ab should also be findable.
2504 | Single character patterns like 'a' appear frequently in this text.
2505 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2506 | It contains multiple lines with various patterns.
2507 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2508 | This helps test case-insensitive searching.
2509 | The quick brown fox jumps over the lazy dog.
2510 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2511 | Short patterns like ab should also be findable.
2512 | Single character patterns like 'a' appear frequently in this text.
2513 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2514 | It contains multiple lines with various patterns.
2515 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2516 | This helps test case-insensitive searching.
2517 | The quick brown fox jumps over the lazy dog.
2518 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2519 | Short patterns like ab should also be findable.
2520 | Single character patterns like 'a' appear frequently in this text.
2521 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2522 | It contains multiple lines with various patterns.
2523 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2524 | This helps test case-insensitive searching.
2525 | The quick brown fox jumps over the lazy dog.
2526 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2527 | Short patterns like ab should also be findable.
2528 | Single character patterns like 'a' appear frequently in this text.
2529 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2530 | It contains multiple lines with various patterns.
2531 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2532 | This helps test case-insensitive searching.
2533 | The quick brown fox jumps over the lazy dog.
2534 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2535 | Short patterns like ab should also be findable.
2536 | Single character patterns like 'a' appear frequently in this text.
2537 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2538 | It contains multiple lines with various patterns.
2539 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2540 | This helps test case-insensitive searching.
2541 | The quick brown fox jumps over the lazy dog.
2542 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2543 | Short patterns like ab should also be findable.
2544 | Single character patterns like 'a' appear frequently in this text.
2545 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2546 | It contains multiple lines with various patterns.
2547 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2548 | This helps test case-insensitive searching.
2549 | The quick brown fox jumps over the lazy dog.
2550 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2551 | Short patterns like ab should also be findable.
2552 | Single character patterns like 'a' appear frequently in this text.
2553 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2554 | It contains multiple lines with various patterns.
2555 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2556 | This helps test case-insensitive searching.
2557 | The quick brown fox jumps over the lazy dog.
2558 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2559 | Short patterns like ab should also be findable.
2560 | Single character patterns like 'a' appear frequently in this text.
2561 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2562 | It contains multiple lines with various patterns.
2563 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2564 | This helps test case-insensitive searching.
2565 | The quick brown fox jumps over the lazy dog.
2566 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2567 | Short patterns like ab should also be findable.
2568 | Single character patterns like 'a' appear frequently in this text.
2569 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2570 | It contains multiple lines with various patterns.
2571 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2572 | This helps test case-insensitive searching.
2573 | The quick brown fox jumps over the lazy dog.
2574 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2575 | Short patterns like ab should also be findable.
2576 | Single character patterns like 'a' appear frequently in this text.
2577 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2578 | It contains multiple lines with various patterns.
2579 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2580 | This helps test case-insensitive searching.
2581 | The quick brown fox jumps over the lazy dog.
2582 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2583 | Short patterns like ab should also be findable.
2584 | Single character patterns like 'a' appear frequently in this text.
2585 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2586 | It contains multiple lines with various patterns.
2587 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2588 | This helps test case-insensitive searching.
2589 | The quick brown fox jumps over the lazy dog.
2590 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2591 | Short patterns like ab should also be findable.
2592 | Single character patterns like 'a' appear frequently in this text.
2593 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2594 | It contains multiple lines with various patterns.
2595 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2596 | This helps test case-insensitive searching.
2597 | The quick brown fox jumps over the lazy dog.
2598 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2599 | Short patterns like ab should also be findable.
2600 | Single character patterns like 'a' appear frequently in this text.
2601 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2602 | It contains multiple lines with various patterns.
2603 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2604 | This helps test case-insensitive searching.
2605 | The quick brown fox jumps over the lazy dog.
2606 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2607 | Short patterns like ab should also be findable.
2608 | Single character patterns like 'a' appear frequently in this text.
2609 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2610 | It contains multiple lines with various patterns.
2611 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2612 | This helps test case-insensitive searching.
2613 | The quick brown fox jumps over the lazy dog.
2614 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2615 | Short patterns like ab should also be findable.
2616 | Single character patterns like 'a' appear frequently in this text.
2617 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2618 | It contains multiple lines with various patterns.
2619 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2620 | This helps test case-insensitive searching.
2621 | The quick brown fox jumps over the lazy dog.
2622 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2623 | Short patterns like ab should also be findable.
2624 | Single character patterns like 'a' appear frequently in this text.
2625 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2626 | It contains multiple lines with various patterns.
2627 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2628 | This helps test case-insensitive searching.
2629 | The quick brown fox jumps over the lazy dog.
2630 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2631 | Short patterns like ab should also be findable.
2632 | Single character patterns like 'a' appear frequently in this text.
2633 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2634 | It contains multiple lines with various patterns.
2635 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2636 | This helps test case-insensitive searching.
2637 | The quick brown fox jumps over the lazy dog.
2638 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2639 | Short patterns like ab should also be findable.
2640 | Single character patterns like 'a' appear frequently in this text.
2641 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2642 | It contains multiple lines with various patterns.
2643 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2644 | This helps test case-insensitive searching.
2645 | The quick brown fox jumps over the lazy dog.
2646 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2647 | Short patterns like ab should also be findable.
2648 | Single character patterns like 'a' appear frequently in this text.
2649 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2650 | It contains multiple lines with various patterns.
2651 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2652 | This helps test case-insensitive searching.
2653 | The quick brown fox jumps over the lazy dog.
2654 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2655 | Short patterns like ab should also be findable.
2656 | Single character patterns like 'a' appear frequently in this text.
2657 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2658 | It contains multiple lines with various patterns.
2659 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2660 | This helps test case-insensitive searching.
2661 | The quick brown fox jumps over the lazy dog.
2662 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2663 | Short patterns like ab should also be findable.
2664 | Single character patterns like 'a' appear frequently in this text.
2665 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2666 | It contains multiple lines with various patterns.
2667 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2668 | This helps test case-insensitive searching.
2669 | The quick brown fox jumps over the lazy dog.
2670 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2671 | Short patterns like ab should also be findable.
2672 | Single character patterns like 'a' appear frequently in this text.
2673 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2674 | It contains multiple lines with various patterns.
2675 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2676 | This helps test case-insensitive searching.
2677 | The quick brown fox jumps over the lazy dog.
2678 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2679 | Short patterns like ab should also be findable.
2680 | Single character patterns like 'a' appear frequently in this text.
2681 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2682 | It contains multiple lines with various patterns.
2683 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2684 | This helps test case-insensitive searching.
2685 | The quick brown fox jumps over the lazy dog.
2686 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2687 | Short patterns like ab should also be findable.
2688 | Single character patterns like 'a' appear frequently in this text.
2689 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2690 | It contains multiple lines with various patterns.
2691 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2692 | This helps test case-insensitive searching.
2693 | The quick brown fox jumps over the lazy dog.
2694 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2695 | Short patterns like ab should also be findable.
2696 | Single character patterns like 'a' appear frequently in this text.
2697 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2698 | It contains multiple lines with various patterns.
2699 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2700 | This helps test case-insensitive searching.
2701 | The quick brown fox jumps over the lazy dog.
2702 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2703 | Short patterns like ab should also be findable.
2704 | Single character patterns like 'a' appear frequently in this text.
2705 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2706 | It contains multiple lines with various patterns.
2707 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2708 | This helps test case-insensitive searching.
2709 | The quick brown fox jumps over the lazy dog.
2710 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2711 | Short patterns like ab should also be findable.
2712 | Single character patterns like 'a' appear frequently in this text.
2713 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2714 | It contains multiple lines with various patterns.
2715 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2716 | This helps test case-insensitive searching.
2717 | The quick brown fox jumps over the lazy dog.
2718 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2719 | Short patterns like ab should also be findable.
2720 | Single character patterns like 'a' appear frequently in this text.
2721 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2722 | It contains multiple lines with various patterns.
2723 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2724 | This helps test case-insensitive searching.
2725 | The quick brown fox jumps over the lazy dog.
2726 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2727 | Short patterns like ab should also be findable.
2728 | Single character patterns like 'a' appear frequently in this text.
2729 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2730 | It contains multiple lines with various patterns.
2731 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2732 | This helps test case-insensitive searching.
2733 | The quick brown fox jumps over the lazy dog.
2734 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2735 | Short patterns like ab should also be findable.
2736 | Single character patterns like 'a' appear frequently in this text.
2737 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2738 | It contains multiple lines with various patterns.
2739 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2740 | This helps test case-insensitive searching.
2741 | The quick brown fox jumps over the lazy dog.
2742 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2743 | Short patterns like ab should also be findable.
2744 | Single character patterns like 'a' appear frequently in this text.
2745 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2746 | It contains multiple lines with various patterns.
2747 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2748 | This helps test case-insensitive searching.
2749 | The quick brown fox jumps over the lazy dog.
2750 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2751 | Short patterns like ab should also be findable.
2752 | Single character patterns like 'a' appear frequently in this text.
2753 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2754 | It contains multiple lines with various patterns.
2755 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2756 | This helps test case-insensitive searching.
2757 | The quick brown fox jumps over the lazy dog.
2758 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2759 | Short patterns like ab should also be findable.
2760 | Single character patterns like 'a' appear frequently in this text.
2761 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2762 | It contains multiple lines with various patterns.
2763 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2764 | This helps test case-insensitive searching.
2765 | The quick brown fox jumps over the lazy dog.
2766 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2767 | Short patterns like ab should also be findable.
2768 | Single character patterns like 'a' appear frequently in this text.
2769 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2770 | It contains multiple lines with various patterns.
2771 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2772 | This helps test case-insensitive searching.
2773 | The quick brown fox jumps over the lazy dog.
2774 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2775 | Short patterns like ab should also be findable.
2776 | Single character patterns like 'a' appear frequently in this text.
2777 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2778 | It contains multiple lines with various patterns.
2779 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2780 | This helps test case-insensitive searching.
2781 | The quick brown fox jumps over the lazy dog.
2782 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2783 | Short patterns like ab should also be findable.
2784 | Single character patterns like 'a' appear frequently in this text.
2785 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2786 | It contains multiple lines with various patterns.
2787 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2788 | This helps test case-insensitive searching.
2789 | The quick brown fox jumps over the lazy dog.
2790 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2791 | Short patterns like ab should also be findable.
2792 | Single character patterns like 'a' appear frequently in this text.
2793 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2794 | It contains multiple lines with various patterns.
2795 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2796 | This helps test case-insensitive searching.
2797 | The quick brown fox jumps over the lazy dog.
2798 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2799 | Short patterns like ab should also be findable.
2800 | Single character patterns like 'a' appear frequently in this text.
2801 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2802 | It contains multiple lines with various patterns.
2803 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2804 | This helps test case-insensitive searching.
2805 | The quick brown fox jumps over the lazy dog.
2806 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2807 | Short patterns like ab should also be findable.
2808 | Single character patterns like 'a' appear frequently in this text.
2809 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2810 | It contains multiple lines with various patterns.
2811 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2812 | This helps test case-insensitive searching.
2813 | The quick brown fox jumps over the lazy dog.
2814 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2815 | Short patterns like ab should also be findable.
2816 | Single character patterns like 'a' appear frequently in this text.
2817 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2818 | It contains multiple lines with various patterns.
2819 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2820 | This helps test case-insensitive searching.
2821 | The quick brown fox jumps over the lazy dog.
2822 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2823 | Short patterns like ab should also be findable.
2824 | Single character patterns like 'a' appear frequently in this text.
2825 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2826 | It contains multiple lines with various patterns.
2827 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2828 | This helps test case-insensitive searching.
2829 | The quick brown fox jumps over the lazy dog.
2830 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2831 | Short patterns like ab should also be findable.
2832 | Single character patterns like 'a' appear frequently in this text.
2833 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2834 | It contains multiple lines with various patterns.
2835 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2836 | This helps test case-insensitive searching.
2837 | The quick brown fox jumps over the lazy dog.
2838 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2839 | Short patterns like ab should also be findable.
2840 | Single character patterns like 'a' appear frequently in this text.
2841 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2842 | It contains multiple lines with various patterns.
2843 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2844 | This helps test case-insensitive searching.
2845 | The quick brown fox jumps over the lazy dog.
2846 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2847 | Short patterns like ab should also be findable.
2848 | Single character patterns like 'a' appear frequently in this text.
2849 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2850 | It contains multiple lines with various patterns.
2851 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2852 | This helps test case-insensitive searching.
2853 | The quick brown fox jumps over the lazy dog.
2854 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2855 | Short patterns like ab should also be findable.
2856 | Single character patterns like 'a' appear frequently in this text.
2857 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2858 | It contains multiple lines with various patterns.
2859 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2860 | This helps test case-insensitive searching.
2861 | The quick brown fox jumps over the lazy dog.
2862 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2863 | Short patterns like ab should also be findable.
2864 | Single character patterns like 'a' appear frequently in this text.
2865 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2866 | It contains multiple lines with various patterns.
2867 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2868 | This helps test case-insensitive searching.
2869 | The quick brown fox jumps over the lazy dog.
2870 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2871 | Short patterns like ab should also be findable.
2872 | Single character patterns like 'a' appear frequently in this text.
2873 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2874 | It contains multiple lines with various patterns.
2875 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2876 | This helps test case-insensitive searching.
2877 | The quick brown fox jumps over the lazy dog.
2878 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2879 | Short patterns like ab should also be findable.
2880 | Single character patterns like 'a' appear frequently in this text.
2881 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2882 | It contains multiple lines with various patterns.
2883 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2884 | This helps test case-insensitive searching.
2885 | The quick brown fox jumps over the lazy dog.
2886 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2887 | Short patterns like ab should also be findable.
2888 | Single character patterns like 'a' appear frequently in this text.
2889 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2890 | It contains multiple lines with various patterns.
2891 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2892 | This helps test case-insensitive searching.
2893 | The quick brown fox jumps over the lazy dog.
2894 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2895 | Short patterns like ab should also be findable.
2896 | Single character patterns like 'a' appear frequently in this text.
2897 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2898 | It contains multiple lines with various patterns.
2899 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2900 | This helps test case-insensitive searching.
2901 | The quick brown fox jumps over the lazy dog.
2902 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2903 | Short patterns like ab should also be findable.
2904 | Single character patterns like 'a' appear frequently in this text.
2905 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2906 | It contains multiple lines with various patterns.
2907 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2908 | This helps test case-insensitive searching.
2909 | The quick brown fox jumps over the lazy dog.
2910 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2911 | Short patterns like ab should also be findable.
2912 | Single character patterns like 'a' appear frequently in this text.
2913 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2914 | It contains multiple lines with various patterns.
2915 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2916 | This helps test case-insensitive searching.
2917 | The quick brown fox jumps over the lazy dog.
2918 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2919 | Short patterns like ab should also be findable.
2920 | Single character patterns like 'a' appear frequently in this text.
2921 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2922 | It contains multiple lines with various patterns.
2923 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2924 | This helps test case-insensitive searching.
2925 | The quick brown fox jumps over the lazy dog.
2926 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2927 | Short patterns like ab should also be findable.
2928 | Single character patterns like 'a' appear frequently in this text.
2929 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2930 | It contains multiple lines with various patterns.
2931 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2932 | This helps test case-insensitive searching.
2933 | The quick brown fox jumps over the lazy dog.
2934 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2935 | Short patterns like ab should also be findable.
2936 | Single character patterns like 'a' appear frequently in this text.
2937 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2938 | It contains multiple lines with various patterns.
2939 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2940 | This helps test case-insensitive searching.
2941 | The quick brown fox jumps over the lazy dog.
2942 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2943 | Short patterns like ab should also be findable.
2944 | Single character patterns like 'a' appear frequently in this text.
2945 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2946 | It contains multiple lines with various patterns.
2947 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2948 | This helps test case-insensitive searching.
2949 | The quick brown fox jumps over the lazy dog.
2950 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2951 | Short patterns like ab should also be findable.
2952 | Single character patterns like 'a' appear frequently in this text.
2953 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2954 | It contains multiple lines with various patterns.
2955 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2956 | This helps test case-insensitive searching.
2957 | The quick brown fox jumps over the lazy dog.
2958 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2959 | Short patterns like ab should also be findable.
2960 | Single character patterns like 'a' appear frequently in this text.
2961 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2962 | It contains multiple lines with various patterns.
2963 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2964 | This helps test case-insensitive searching.
2965 | The quick brown fox jumps over the lazy dog.
2966 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2967 | Short patterns like ab should also be findable.
2968 | Single character patterns like 'a' appear frequently in this text.
2969 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2970 | It contains multiple lines with various patterns.
2971 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2972 | This helps test case-insensitive searching.
2973 | The quick brown fox jumps over the lazy dog.
2974 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2975 | Short patterns like ab should also be findable.
2976 | Single character patterns like 'a' appear frequently in this text.
2977 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2978 | It contains multiple lines with various patterns.
2979 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2980 | This helps test case-insensitive searching.
2981 | The quick brown fox jumps over the lazy dog.
2982 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2983 | Short patterns like ab should also be findable.
2984 | Single character patterns like 'a' appear frequently in this text.
2985 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2986 | It contains multiple lines with various patterns.
2987 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2988 | This helps test case-insensitive searching.
2989 | The quick brown fox jumps over the lazy dog.
2990 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2991 | Short patterns like ab should also be findable.
2992 | Single character patterns like 'a' appear frequently in this text.
2993 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
2994 | It contains multiple lines with various patterns.
2995 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
2996 | This helps test case-insensitive searching.
2997 | The quick brown fox jumps over the lazy dog.
2998 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
2999 | Short patterns like ab should also be findable.
3000 | Single character patterns like 'a' appear frequently in this text.
3001 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3002 | It contains multiple lines with various patterns.
3003 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3004 | This helps test case-insensitive searching.
3005 | The quick brown fox jumps over the lazy dog.
3006 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3007 | Short patterns like ab should also be findable.
3008 | Single character patterns like 'a' appear frequently in this text.
3009 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3010 | It contains multiple lines with various patterns.
3011 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3012 | This helps test case-insensitive searching.
3013 | The quick brown fox jumps over the lazy dog.
3014 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3015 | Short patterns like ab should also be findable.
3016 | Single character patterns like 'a' appear frequently in this text.
3017 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3018 | It contains multiple lines with various patterns.
3019 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3020 | This helps test case-insensitive searching.
3021 | The quick brown fox jumps over the lazy dog.
3022 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3023 | Short patterns like ab should also be findable.
3024 | Single character patterns like 'a' appear frequently in this text.
3025 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3026 | It contains multiple lines with various patterns.
3027 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3028 | This helps test case-insensitive searching.
3029 | The quick brown fox jumps over the lazy dog.
3030 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3031 | Short patterns like ab should also be findable.
3032 | Single character patterns like 'a' appear frequently in this text.
3033 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3034 | It contains multiple lines with various patterns.
3035 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3036 | This helps test case-insensitive searching.
3037 | The quick brown fox jumps over the lazy dog.
3038 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3039 | Short patterns like ab should also be findable.
3040 | Single character patterns like 'a' appear frequently in this text.
3041 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3042 | It contains multiple lines with various patterns.
3043 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3044 | This helps test case-insensitive searching.
3045 | The quick brown fox jumps over the lazy dog.
3046 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3047 | Short patterns like ab should also be findable.
3048 | Single character patterns like 'a' appear frequently in this text.
3049 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3050 | It contains multiple lines with various patterns.
3051 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3052 | This helps test case-insensitive searching.
3053 | The quick brown fox jumps over the lazy dog.
3054 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3055 | Short patterns like ab should also be findable.
3056 | Single character patterns like 'a' appear frequently in this text.
3057 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3058 | It contains multiple lines with various patterns.
3059 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3060 | This helps test case-insensitive searching.
3061 | The quick brown fox jumps over the lazy dog.
3062 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3063 | Short patterns like ab should also be findable.
3064 | Single character patterns like 'a' appear frequently in this text.
3065 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3066 | It contains multiple lines with various patterns.
3067 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3068 | This helps test case-insensitive searching.
3069 | The quick brown fox jumps over the lazy dog.
3070 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3071 | Short patterns like ab should also be findable.
3072 | Single character patterns like 'a' appear frequently in this text.
3073 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3074 | It contains multiple lines with various patterns.
3075 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3076 | This helps test case-insensitive searching.
3077 | The quick brown fox jumps over the lazy dog.
3078 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3079 | Short patterns like ab should also be findable.
3080 | Single character patterns like 'a' appear frequently in this text.
3081 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3082 | It contains multiple lines with various patterns.
3083 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3084 | This helps test case-insensitive searching.
3085 | The quick brown fox jumps over the lazy dog.
3086 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3087 | Short patterns like ab should also be findable.
3088 | Single character patterns like 'a' appear frequently in this text.
3089 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3090 | It contains multiple lines with various patterns.
3091 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3092 | This helps test case-insensitive searching.
3093 | The quick brown fox jumps over the lazy dog.
3094 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3095 | Short patterns like ab should also be findable.
3096 | Single character patterns like 'a' appear frequently in this text.
3097 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3098 | It contains multiple lines with various patterns.
3099 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3100 | This helps test case-insensitive searching.
3101 | The quick brown fox jumps over the lazy dog.
3102 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3103 | Short patterns like ab should also be findable.
3104 | Single character patterns like 'a' appear frequently in this text.
3105 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3106 | It contains multiple lines with various patterns.
3107 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3108 | This helps test case-insensitive searching.
3109 | The quick brown fox jumps over the lazy dog.
3110 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3111 | Short patterns like ab should also be findable.
3112 | Single character patterns like 'a' appear frequently in this text.
3113 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3114 | It contains multiple lines with various patterns.
3115 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3116 | This helps test case-insensitive searching.
3117 | The quick brown fox jumps over the lazy dog.
3118 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3119 | Short patterns like ab should also be findable.
3120 | Single character patterns like 'a' appear frequently in this text.
3121 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3122 | It contains multiple lines with various patterns.
3123 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3124 | This helps test case-insensitive searching.
3125 | The quick brown fox jumps over the lazy dog.
3126 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3127 | Short patterns like ab should also be findable.
3128 | Single character patterns like 'a' appear frequently in this text.
3129 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3130 | It contains multiple lines with various patterns.
3131 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3132 | This helps test case-insensitive searching.
3133 | The quick brown fox jumps over the lazy dog.
3134 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3135 | Short patterns like ab should also be findable.
3136 | Single character patterns like 'a' appear frequently in this text.
3137 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3138 | It contains multiple lines with various patterns.
3139 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3140 | This helps test case-insensitive searching.
3141 | The quick brown fox jumps over the lazy dog.
3142 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3143 | Short patterns like ab should also be findable.
3144 | Single character patterns like 'a' appear frequently in this text.
3145 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3146 | It contains multiple lines with various patterns.
3147 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3148 | This helps test case-insensitive searching.
3149 | The quick brown fox jumps over the lazy dog.
3150 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3151 | Short patterns like ab should also be findable.
3152 | Single character patterns like 'a' appear frequently in this text.
3153 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3154 | It contains multiple lines with various patterns.
3155 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3156 | This helps test case-insensitive searching.
3157 | The quick brown fox jumps over the lazy dog.
3158 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3159 | Short patterns like ab should also be findable.
3160 | Single character patterns like 'a' appear frequently in this text.
3161 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3162 | It contains multiple lines with various patterns.
3163 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3164 | This helps test case-insensitive searching.
3165 | The quick brown fox jumps over the lazy dog.
3166 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3167 | Short patterns like ab should also be findable.
3168 | Single character patterns like 'a' appear frequently in this text.
3169 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3170 | It contains multiple lines with various patterns.
3171 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3172 | This helps test case-insensitive searching.
3173 | The quick brown fox jumps over the lazy dog.
3174 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3175 | Short patterns like ab should also be findable.
3176 | Single character patterns like 'a' appear frequently in this text.
3177 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3178 | It contains multiple lines with various patterns.
3179 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3180 | This helps test case-insensitive searching.
3181 | The quick brown fox jumps over the lazy dog.
3182 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3183 | Short patterns like ab should also be findable.
3184 | Single character patterns like 'a' appear frequently in this text.
3185 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3186 | It contains multiple lines with various patterns.
3187 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3188 | This helps test case-insensitive searching.
3189 | The quick brown fox jumps over the lazy dog.
3190 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3191 | Short patterns like ab should also be findable.
3192 | Single character patterns like 'a' appear frequently in this text.
3193 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3194 | It contains multiple lines with various patterns.
3195 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3196 | This helps test case-insensitive searching.
3197 | The quick brown fox jumps over the lazy dog.
3198 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3199 | Short patterns like ab should also be findable.
3200 | Single character patterns like 'a' appear frequently in this text.
3201 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3202 | It contains multiple lines with various patterns.
3203 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3204 | This helps test case-insensitive searching.
3205 | The quick brown fox jumps over the lazy dog.
3206 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3207 | Short patterns like ab should also be findable.
3208 | Single character patterns like 'a' appear frequently in this text.
3209 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3210 | It contains multiple lines with various patterns.
3211 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3212 | This helps test case-insensitive searching.
3213 | The quick brown fox jumps over the lazy dog.
3214 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3215 | Short patterns like ab should also be findable.
3216 | Single character patterns like 'a' appear frequently in this text.
3217 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3218 | It contains multiple lines with various patterns.
3219 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3220 | This helps test case-insensitive searching.
3221 | The quick brown fox jumps over the lazy dog.
3222 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3223 | Short patterns like ab should also be findable.
3224 | Single character patterns like 'a' appear frequently in this text.
3225 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3226 | It contains multiple lines with various patterns.
3227 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3228 | This helps test case-insensitive searching.
3229 | The quick brown fox jumps over the lazy dog.
3230 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3231 | Short patterns like ab should also be findable.
3232 | Single character patterns like 'a' appear frequently in this text.
3233 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3234 | It contains multiple lines with various patterns.
3235 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3236 | This helps test case-insensitive searching.
3237 | The quick brown fox jumps over the lazy dog.
3238 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3239 | Short patterns like ab should also be findable.
3240 | Single character patterns like 'a' appear frequently in this text.
3241 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3242 | It contains multiple lines with various patterns.
3243 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3244 | This helps test case-insensitive searching.
3245 | The quick brown fox jumps over the lazy dog.
3246 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3247 | Short patterns like ab should also be findable.
3248 | Single character patterns like 'a' appear frequently in this text.
3249 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3250 | It contains multiple lines with various patterns.
3251 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3252 | This helps test case-insensitive searching.
3253 | The quick brown fox jumps over the lazy dog.
3254 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3255 | Short patterns like ab should also be findable.
3256 | Single character patterns like 'a' appear frequently in this text.
3257 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3258 | It contains multiple lines with various patterns.
3259 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3260 | This helps test case-insensitive searching.
3261 | The quick brown fox jumps over the lazy dog.
3262 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3263 | Short patterns like ab should also be findable.
3264 | Single character patterns like 'a' appear frequently in this text.
3265 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3266 | It contains multiple lines with various patterns.
3267 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3268 | This helps test case-insensitive searching.
3269 | The quick brown fox jumps over the lazy dog.
3270 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3271 | Short patterns like ab should also be findable.
3272 | Single character patterns like 'a' appear frequently in this text.
3273 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3274 | It contains multiple lines with various patterns.
3275 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3276 | This helps test case-insensitive searching.
3277 | The quick brown fox jumps over the lazy dog.
3278 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3279 | Short patterns like ab should also be findable.
3280 | Single character patterns like 'a' appear frequently in this text.
3281 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3282 | It contains multiple lines with various patterns.
3283 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3284 | This helps test case-insensitive searching.
3285 | The quick brown fox jumps over the lazy dog.
3286 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3287 | Short patterns like ab should also be findable.
3288 | Single character patterns like 'a' appear frequently in this text.
3289 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3290 | It contains multiple lines with various patterns.
3291 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3292 | This helps test case-insensitive searching.
3293 | The quick brown fox jumps over the lazy dog.
3294 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3295 | Short patterns like ab should also be findable.
3296 | Single character patterns like 'a' appear frequently in this text.
3297 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3298 | It contains multiple lines with various patterns.
3299 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3300 | This helps test case-insensitive searching.
3301 | The quick brown fox jumps over the lazy dog.
3302 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3303 | Short patterns like ab should also be findable.
3304 | Single character patterns like 'a' appear frequently in this text.
3305 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3306 | It contains multiple lines with various patterns.
3307 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3308 | This helps test case-insensitive searching.
3309 | The quick brown fox jumps over the lazy dog.
3310 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3311 | Short patterns like ab should also be findable.
3312 | Single character patterns like 'a' appear frequently in this text.
3313 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3314 | It contains multiple lines with various patterns.
3315 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3316 | This helps test case-insensitive searching.
3317 | The quick brown fox jumps over the lazy dog.
3318 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3319 | Short patterns like ab should also be findable.
3320 | Single character patterns like 'a' appear frequently in this text.
3321 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3322 | It contains multiple lines with various patterns.
3323 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3324 | This helps test case-insensitive searching.
3325 | The quick brown fox jumps over the lazy dog.
3326 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3327 | Short patterns like ab should also be findable.
3328 | Single character patterns like 'a' appear frequently in this text.
3329 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3330 | It contains multiple lines with various patterns.
3331 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3332 | This helps test case-insensitive searching.
3333 | The quick brown fox jumps over the lazy dog.
3334 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3335 | Short patterns like ab should also be findable.
3336 | Single character patterns like 'a' appear frequently in this text.
3337 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3338 | It contains multiple lines with various patterns.
3339 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3340 | This helps test case-insensitive searching.
3341 | The quick brown fox jumps over the lazy dog.
3342 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3343 | Short patterns like ab should also be findable.
3344 | Single character patterns like 'a' appear frequently in this text.
3345 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3346 | It contains multiple lines with various patterns.
3347 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3348 | This helps test case-insensitive searching.
3349 | The quick brown fox jumps over the lazy dog.
3350 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3351 | Short patterns like ab should also be findable.
3352 | Single character patterns like 'a' appear frequently in this text.
3353 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3354 | It contains multiple lines with various patterns.
3355 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3356 | This helps test case-insensitive searching.
3357 | The quick brown fox jumps over the lazy dog.
3358 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3359 | Short patterns like ab should also be findable.
3360 | Single character patterns like 'a' appear frequently in this text.
3361 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3362 | It contains multiple lines with various patterns.
3363 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3364 | This helps test case-insensitive searching.
3365 | The quick brown fox jumps over the lazy dog.
3366 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3367 | Short patterns like ab should also be findable.
3368 | Single character patterns like 'a' appear frequently in this text.
3369 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3370 | It contains multiple lines with various patterns.
3371 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3372 | This helps test case-insensitive searching.
3373 | The quick brown fox jumps over the lazy dog.
3374 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3375 | Short patterns like ab should also be findable.
3376 | Single character patterns like 'a' appear frequently in this text.
3377 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3378 | It contains multiple lines with various patterns.
3379 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3380 | This helps test case-insensitive searching.
3381 | The quick brown fox jumps over the lazy dog.
3382 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3383 | Short patterns like ab should also be findable.
3384 | Single character patterns like 'a' appear frequently in this text.
3385 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3386 | It contains multiple lines with various patterns.
3387 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3388 | This helps test case-insensitive searching.
3389 | The quick brown fox jumps over the lazy dog.
3390 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3391 | Short patterns like ab should also be findable.
3392 | Single character patterns like 'a' appear frequently in this text.
3393 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3394 | It contains multiple lines with various patterns.
3395 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3396 | This helps test case-insensitive searching.
3397 | The quick brown fox jumps over the lazy dog.
3398 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3399 | Short patterns like ab should also be findable.
3400 | Single character patterns like 'a' appear frequently in this text.
3401 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3402 | It contains multiple lines with various patterns.
3403 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3404 | This helps test case-insensitive searching.
3405 | The quick brown fox jumps over the lazy dog.
3406 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3407 | Short patterns like ab should also be findable.
3408 | Single character patterns like 'a' appear frequently in this text.
3409 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3410 | It contains multiple lines with various patterns.
3411 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3412 | This helps test case-insensitive searching.
3413 | The quick brown fox jumps over the lazy dog.
3414 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3415 | Short patterns like ab should also be findable.
3416 | Single character patterns like 'a' appear frequently in this text.
3417 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3418 | It contains multiple lines with various patterns.
3419 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3420 | This helps test case-insensitive searching.
3421 | The quick brown fox jumps over the lazy dog.
3422 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3423 | Short patterns like ab should also be findable.
3424 | Single character patterns like 'a' appear frequently in this text.
3425 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3426 | It contains multiple lines with various patterns.
3427 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3428 | This helps test case-insensitive searching.
3429 | The quick brown fox jumps over the lazy dog.
3430 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3431 | Short patterns like ab should also be findable.
3432 | Single character patterns like 'a' appear frequently in this text.
3433 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3434 | It contains multiple lines with various patterns.
3435 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3436 | This helps test case-insensitive searching.
3437 | The quick brown fox jumps over the lazy dog.
3438 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3439 | Short patterns like ab should also be findable.
3440 | Single character patterns like 'a' appear frequently in this text.
3441 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3442 | It contains multiple lines with various patterns.
3443 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3444 | This helps test case-insensitive searching.
3445 | The quick brown fox jumps over the lazy dog.
3446 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3447 | Short patterns like ab should also be findable.
3448 | Single character patterns like 'a' appear frequently in this text.
3449 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3450 | It contains multiple lines with various patterns.
3451 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3452 | This helps test case-insensitive searching.
3453 | The quick brown fox jumps over the lazy dog.
3454 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3455 | Short patterns like ab should also be findable.
3456 | Single character patterns like 'a' appear frequently in this text.
3457 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3458 | It contains multiple lines with various patterns.
3459 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3460 | This helps test case-insensitive searching.
3461 | The quick brown fox jumps over the lazy dog.
3462 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3463 | Short patterns like ab should also be findable.
3464 | Single character patterns like 'a' appear frequently in this text.
3465 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3466 | It contains multiple lines with various patterns.
3467 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3468 | This helps test case-insensitive searching.
3469 | The quick brown fox jumps over the lazy dog.
3470 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3471 | Short patterns like ab should also be findable.
3472 | Single character patterns like 'a' appear frequently in this text.
3473 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3474 | It contains multiple lines with various patterns.
3475 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3476 | This helps test case-insensitive searching.
3477 | The quick brown fox jumps over the lazy dog.
3478 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3479 | Short patterns like ab should also be findable.
3480 | Single character patterns like 'a' appear frequently in this text.
3481 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3482 | It contains multiple lines with various patterns.
3483 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3484 | This helps test case-insensitive searching.
3485 | The quick brown fox jumps over the lazy dog.
3486 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3487 | Short patterns like ab should also be findable.
3488 | Single character patterns like 'a' appear frequently in this text.
3489 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3490 | It contains multiple lines with various patterns.
3491 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3492 | This helps test case-insensitive searching.
3493 | The quick brown fox jumps over the lazy dog.
3494 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3495 | Short patterns like ab should also be findable.
3496 | Single character patterns like 'a' appear frequently in this text.
3497 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3498 | It contains multiple lines with various patterns.
3499 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3500 | This helps test case-insensitive searching.
3501 | The quick brown fox jumps over the lazy dog.
3502 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3503 | Short patterns like ab should also be findable.
3504 | Single character patterns like 'a' appear frequently in this text.
3505 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3506 | It contains multiple lines with various patterns.
3507 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3508 | This helps test case-insensitive searching.
3509 | The quick brown fox jumps over the lazy dog.
3510 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3511 | Short patterns like ab should also be findable.
3512 | Single character patterns like 'a' appear frequently in this text.
3513 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3514 | It contains multiple lines with various patterns.
3515 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3516 | This helps test case-insensitive searching.
3517 | The quick brown fox jumps over the lazy dog.
3518 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3519 | Short patterns like ab should also be findable.
3520 | Single character patterns like 'a' appear frequently in this text.
3521 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3522 | It contains multiple lines with various patterns.
3523 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3524 | This helps test case-insensitive searching.
3525 | The quick brown fox jumps over the lazy dog.
3526 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3527 | Short patterns like ab should also be findable.
3528 | Single character patterns like 'a' appear frequently in this text.
3529 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3530 | It contains multiple lines with various patterns.
3531 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3532 | This helps test case-insensitive searching.
3533 | The quick brown fox jumps over the lazy dog.
3534 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3535 | Short patterns like ab should also be findable.
3536 | Single character patterns like 'a' appear frequently in this text.
3537 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3538 | It contains multiple lines with various patterns.
3539 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3540 | This helps test case-insensitive searching.
3541 | The quick brown fox jumps over the lazy dog.
3542 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3543 | Short patterns like ab should also be findable.
3544 | Single character patterns like 'a' appear frequently in this text.
3545 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3546 | It contains multiple lines with various patterns.
3547 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3548 | This helps test case-insensitive searching.
3549 | The quick brown fox jumps over the lazy dog.
3550 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3551 | Short patterns like ab should also be findable.
3552 | Single character patterns like 'a' appear frequently in this text.
3553 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3554 | It contains multiple lines with various patterns.
3555 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3556 | This helps test case-insensitive searching.
3557 | The quick brown fox jumps over the lazy dog.
3558 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3559 | Short patterns like ab should also be findable.
3560 | Single character patterns like 'a' appear frequently in this text.
3561 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3562 | It contains multiple lines with various patterns.
3563 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3564 | This helps test case-insensitive searching.
3565 | The quick brown fox jumps over the lazy dog.
3566 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3567 | Short patterns like ab should also be findable.
3568 | Single character patterns like 'a' appear frequently in this text.
3569 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3570 | It contains multiple lines with various patterns.
3571 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3572 | This helps test case-insensitive searching.
3573 | The quick brown fox jumps over the lazy dog.
3574 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3575 | Short patterns like ab should also be findable.
3576 | Single character patterns like 'a' appear frequently in this text.
3577 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3578 | It contains multiple lines with various patterns.
3579 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3580 | This helps test case-insensitive searching.
3581 | The quick brown fox jumps over the lazy dog.
3582 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3583 | Short patterns like ab should also be findable.
3584 | Single character patterns like 'a' appear frequently in this text.
3585 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3586 | It contains multiple lines with various patterns.
3587 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3588 | This helps test case-insensitive searching.
3589 | The quick brown fox jumps over the lazy dog.
3590 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3591 | Short patterns like ab should also be findable.
3592 | Single character patterns like 'a' appear frequently in this text.
3593 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3594 | It contains multiple lines with various patterns.
3595 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3596 | This helps test case-insensitive searching.
3597 | The quick brown fox jumps over the lazy dog.
3598 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3599 | Short patterns like ab should also be findable.
3600 | Single character patterns like 'a' appear frequently in this text.
3601 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3602 | It contains multiple lines with various patterns.
3603 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3604 | This helps test case-insensitive searching.
3605 | The quick brown fox jumps over the lazy dog.
3606 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3607 | Short patterns like ab should also be findable.
3608 | Single character patterns like 'a' appear frequently in this text.
3609 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3610 | It contains multiple lines with various patterns.
3611 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3612 | This helps test case-insensitive searching.
3613 | The quick brown fox jumps over the lazy dog.
3614 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3615 | Short patterns like ab should also be findable.
3616 | Single character patterns like 'a' appear frequently in this text.
3617 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3618 | It contains multiple lines with various patterns.
3619 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3620 | This helps test case-insensitive searching.
3621 | The quick brown fox jumps over the lazy dog.
3622 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3623 | Short patterns like ab should also be findable.
3624 | Single character patterns like 'a' appear frequently in this text.
3625 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3626 | It contains multiple lines with various patterns.
3627 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3628 | This helps test case-insensitive searching.
3629 | The quick brown fox jumps over the lazy dog.
3630 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3631 | Short patterns like ab should also be findable.
3632 | Single character patterns like 'a' appear frequently in this text.
3633 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3634 | It contains multiple lines with various patterns.
3635 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3636 | This helps test case-insensitive searching.
3637 | The quick brown fox jumps over the lazy dog.
3638 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3639 | Short patterns like ab should also be findable.
3640 | Single character patterns like 'a' appear frequently in this text.
3641 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3642 | It contains multiple lines with various patterns.
3643 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3644 | This helps test case-insensitive searching.
3645 | The quick brown fox jumps over the lazy dog.
3646 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3647 | Short patterns like ab should also be findable.
3648 | Single character patterns like 'a' appear frequently in this text.
3649 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3650 | It contains multiple lines with various patterns.
3651 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3652 | This helps test case-insensitive searching.
3653 | The quick brown fox jumps over the lazy dog.
3654 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3655 | Short patterns like ab should also be findable.
3656 | Single character patterns like 'a' appear frequently in this text.
3657 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3658 | It contains multiple lines with various patterns.
3659 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3660 | This helps test case-insensitive searching.
3661 | The quick brown fox jumps over the lazy dog.
3662 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3663 | Short patterns like ab should also be findable.
3664 | Single character patterns like 'a' appear frequently in this text.
3665 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3666 | It contains multiple lines with various patterns.
3667 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3668 | This helps test case-insensitive searching.
3669 | The quick brown fox jumps over the lazy dog.
3670 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3671 | Short patterns like ab should also be findable.
3672 | Single character patterns like 'a' appear frequently in this text.
3673 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3674 | It contains multiple lines with various patterns.
3675 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3676 | This helps test case-insensitive searching.
3677 | The quick brown fox jumps over the lazy dog.
3678 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3679 | Short patterns like ab should also be findable.
3680 | Single character patterns like 'a' appear frequently in this text.
3681 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3682 | It contains multiple lines with various patterns.
3683 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3684 | This helps test case-insensitive searching.
3685 | The quick brown fox jumps over the lazy dog.
3686 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3687 | Short patterns like ab should also be findable.
3688 | Single character patterns like 'a' appear frequently in this text.
3689 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3690 | It contains multiple lines with various patterns.
3691 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3692 | This helps test case-insensitive searching.
3693 | The quick brown fox jumps over the lazy dog.
3694 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3695 | Short patterns like ab should also be findable.
3696 | Single character patterns like 'a' appear frequently in this text.
3697 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3698 | It contains multiple lines with various patterns.
3699 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3700 | This helps test case-insensitive searching.
3701 | The quick brown fox jumps over the lazy dog.
3702 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3703 | Short patterns like ab should also be findable.
3704 | Single character patterns like 'a' appear frequently in this text.
3705 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3706 | It contains multiple lines with various patterns.
3707 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3708 | This helps test case-insensitive searching.
3709 | The quick brown fox jumps over the lazy dog.
3710 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3711 | Short patterns like ab should also be findable.
3712 | Single character patterns like 'a' appear frequently in this text.
3713 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3714 | It contains multiple lines with various patterns.
3715 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3716 | This helps test case-insensitive searching.
3717 | The quick brown fox jumps over the lazy dog.
3718 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3719 | Short patterns like ab should also be findable.
3720 | Single character patterns like 'a' appear frequently in this text.
3721 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3722 | It contains multiple lines with various patterns.
3723 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3724 | This helps test case-insensitive searching.
3725 | The quick brown fox jumps over the lazy dog.
3726 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3727 | Short patterns like ab should also be findable.
3728 | Single character patterns like 'a' appear frequently in this text.
3729 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3730 | It contains multiple lines with various patterns.
3731 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3732 | This helps test case-insensitive searching.
3733 | The quick brown fox jumps over the lazy dog.
3734 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3735 | Short patterns like ab should also be findable.
3736 | Single character patterns like 'a' appear frequently in this text.
3737 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3738 | It contains multiple lines with various patterns.
3739 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3740 | This helps test case-insensitive searching.
3741 | The quick brown fox jumps over the lazy dog.
3742 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3743 | Short patterns like ab should also be findable.
3744 | Single character patterns like 'a' appear frequently in this text.
3745 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3746 | It contains multiple lines with various patterns.
3747 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3748 | This helps test case-insensitive searching.
3749 | The quick brown fox jumps over the lazy dog.
3750 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3751 | Short patterns like ab should also be findable.
3752 | Single character patterns like 'a' appear frequently in this text.
3753 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3754 | It contains multiple lines with various patterns.
3755 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3756 | This helps test case-insensitive searching.
3757 | The quick brown fox jumps over the lazy dog.
3758 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3759 | Short patterns like ab should also be findable.
3760 | Single character patterns like 'a' appear frequently in this text.
3761 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3762 | It contains multiple lines with various patterns.
3763 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3764 | This helps test case-insensitive searching.
3765 | The quick brown fox jumps over the lazy dog.
3766 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3767 | Short patterns like ab should also be findable.
3768 | Single character patterns like 'a' appear frequently in this text.
3769 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3770 | It contains multiple lines with various patterns.
3771 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3772 | This helps test case-insensitive searching.
3773 | The quick brown fox jumps over the lazy dog.
3774 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3775 | Short patterns like ab should also be findable.
3776 | Single character patterns like 'a' appear frequently in this text.
3777 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3778 | It contains multiple lines with various patterns.
3779 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3780 | This helps test case-insensitive searching.
3781 | The quick brown fox jumps over the lazy dog.
3782 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3783 | Short patterns like ab should also be findable.
3784 | Single character patterns like 'a' appear frequently in this text.
3785 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3786 | It contains multiple lines with various patterns.
3787 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3788 | This helps test case-insensitive searching.
3789 | The quick brown fox jumps over the lazy dog.
3790 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3791 | Short patterns like ab should also be findable.
3792 | Single character patterns like 'a' appear frequently in this text.
3793 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3794 | It contains multiple lines with various patterns.
3795 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3796 | This helps test case-insensitive searching.
3797 | The quick brown fox jumps over the lazy dog.
3798 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3799 | Short patterns like ab should also be findable.
3800 | Single character patterns like 'a' appear frequently in this text.
3801 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3802 | It contains multiple lines with various patterns.
3803 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3804 | This helps test case-insensitive searching.
3805 | The quick brown fox jumps over the lazy dog.
3806 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3807 | Short patterns like ab should also be findable.
3808 | Single character patterns like 'a' appear frequently in this text.
3809 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3810 | It contains multiple lines with various patterns.
3811 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3812 | This helps test case-insensitive searching.
3813 | The quick brown fox jumps over the lazy dog.
3814 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3815 | Short patterns like ab should also be findable.
3816 | Single character patterns like 'a' appear frequently in this text.
3817 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3818 | It contains multiple lines with various patterns.
3819 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3820 | This helps test case-insensitive searching.
3821 | The quick brown fox jumps over the lazy dog.
3822 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3823 | Short patterns like ab should also be findable.
3824 | Single character patterns like 'a' appear frequently in this text.
3825 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3826 | It contains multiple lines with various patterns.
3827 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3828 | This helps test case-insensitive searching.
3829 | The quick brown fox jumps over the lazy dog.
3830 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3831 | Short patterns like ab should also be findable.
3832 | Single character patterns like 'a' appear frequently in this text.
3833 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3834 | It contains multiple lines with various patterns.
3835 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3836 | This helps test case-insensitive searching.
3837 | The quick brown fox jumps over the lazy dog.
3838 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3839 | Short patterns like ab should also be findable.
3840 | Single character patterns like 'a' appear frequently in this text.
3841 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3842 | It contains multiple lines with various patterns.
3843 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3844 | This helps test case-insensitive searching.
3845 | The quick brown fox jumps over the lazy dog.
3846 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3847 | Short patterns like ab should also be findable.
3848 | Single character patterns like 'a' appear frequently in this text.
3849 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3850 | It contains multiple lines with various patterns.
3851 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3852 | This helps test case-insensitive searching.
3853 | The quick brown fox jumps over the lazy dog.
3854 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3855 | Short patterns like ab should also be findable.
3856 | Single character patterns like 'a' appear frequently in this text.
3857 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3858 | It contains multiple lines with various patterns.
3859 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3860 | This helps test case-insensitive searching.
3861 | The quick brown fox jumps over the lazy dog.
3862 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3863 | Short patterns like ab should also be findable.
3864 | Single character patterns like 'a' appear frequently in this text.
3865 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3866 | It contains multiple lines with various patterns.
3867 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3868 | This helps test case-insensitive searching.
3869 | The quick brown fox jumps over the lazy dog.
3870 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3871 | Short patterns like ab should also be findable.
3872 | Single character patterns like 'a' appear frequently in this text.
3873 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3874 | It contains multiple lines with various patterns.
3875 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3876 | This helps test case-insensitive searching.
3877 | The quick brown fox jumps over the lazy dog.
3878 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3879 | Short patterns like ab should also be findable.
3880 | Single character patterns like 'a' appear frequently in this text.
3881 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3882 | It contains multiple lines with various patterns.
3883 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3884 | This helps test case-insensitive searching.
3885 | The quick brown fox jumps over the lazy dog.
3886 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3887 | Short patterns like ab should also be findable.
3888 | Single character patterns like 'a' appear frequently in this text.
3889 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3890 | It contains multiple lines with various patterns.
3891 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3892 | This helps test case-insensitive searching.
3893 | The quick brown fox jumps over the lazy dog.
3894 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3895 | Short patterns like ab should also be findable.
3896 | Single character patterns like 'a' appear frequently in this text.
3897 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3898 | It contains multiple lines with various patterns.
3899 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3900 | This helps test case-insensitive searching.
3901 | The quick brown fox jumps over the lazy dog.
3902 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3903 | Short patterns like ab should also be findable.
3904 | Single character patterns like 'a' appear frequently in this text.
3905 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3906 | It contains multiple lines with various patterns.
3907 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3908 | This helps test case-insensitive searching.
3909 | The quick brown fox jumps over the lazy dog.
3910 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3911 | Short patterns like ab should also be findable.
3912 | Single character patterns like 'a' appear frequently in this text.
3913 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3914 | It contains multiple lines with various patterns.
3915 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3916 | This helps test case-insensitive searching.
3917 | The quick brown fox jumps over the lazy dog.
3918 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3919 | Short patterns like ab should also be findable.
3920 | Single character patterns like 'a' appear frequently in this text.
3921 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3922 | It contains multiple lines with various patterns.
3923 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3924 | This helps test case-insensitive searching.
3925 | The quick brown fox jumps over the lazy dog.
3926 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3927 | Short patterns like ab should also be findable.
3928 | Single character patterns like 'a' appear frequently in this text.
3929 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3930 | It contains multiple lines with various patterns.
3931 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3932 | This helps test case-insensitive searching.
3933 | The quick brown fox jumps over the lazy dog.
3934 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3935 | Short patterns like ab should also be findable.
3936 | Single character patterns like 'a' appear frequently in this text.
3937 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3938 | It contains multiple lines with various patterns.
3939 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3940 | This helps test case-insensitive searching.
3941 | The quick brown fox jumps over the lazy dog.
3942 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3943 | Short patterns like ab should also be findable.
3944 | Single character patterns like 'a' appear frequently in this text.
3945 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3946 | It contains multiple lines with various patterns.
3947 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3948 | This helps test case-insensitive searching.
3949 | The quick brown fox jumps over the lazy dog.
3950 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3951 | Short patterns like ab should also be findable.
3952 | Single character patterns like 'a' appear frequently in this text.
3953 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3954 | It contains multiple lines with various patterns.
3955 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3956 | This helps test case-insensitive searching.
3957 | The quick brown fox jumps over the lazy dog.
3958 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3959 | Short patterns like ab should also be findable.
3960 | Single character patterns like 'a' appear frequently in this text.
3961 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3962 | It contains multiple lines with various patterns.
3963 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3964 | This helps test case-insensitive searching.
3965 | The quick brown fox jumps over the lazy dog.
3966 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3967 | Short patterns like ab should also be findable.
3968 | Single character patterns like 'a' appear frequently in this text.
3969 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3970 | It contains multiple lines with various patterns.
3971 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3972 | This helps test case-insensitive searching.
3973 | The quick brown fox jumps over the lazy dog.
3974 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3975 | Short patterns like ab should also be findable.
3976 | Single character patterns like 'a' appear frequently in this text.
3977 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3978 | It contains multiple lines with various patterns.
3979 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3980 | This helps test case-insensitive searching.
3981 | The quick brown fox jumps over the lazy dog.
3982 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3983 | Short patterns like ab should also be findable.
3984 | Single character patterns like 'a' appear frequently in this text.
3985 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3986 | It contains multiple lines with various patterns.
3987 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3988 | This helps test case-insensitive searching.
3989 | The quick brown fox jumps over the lazy dog.
3990 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3991 | Short patterns like ab should also be findable.
3992 | Single character patterns like 'a' appear frequently in this text.
3993 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
3994 | It contains multiple lines with various patterns.
3995 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
3996 | This helps test case-insensitive searching.
3997 | The quick brown fox jumps over the lazy dog.
3998 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
3999 | Short patterns like ab should also be findable.
4000 | Single character patterns like 'a' appear frequently in this text.
4001 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4002 | It contains multiple lines with various patterns.
4003 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4004 | This helps test case-insensitive searching.
4005 | The quick brown fox jumps over the lazy dog.
4006 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4007 | Short patterns like ab should also be findable.
4008 | Single character patterns like 'a' appear frequently in this text.
4009 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4010 | It contains multiple lines with various patterns.
4011 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4012 | This helps test case-insensitive searching.
4013 | The quick brown fox jumps over the lazy dog.
4014 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4015 | Short patterns like ab should also be findable.
4016 | Single character patterns like 'a' appear frequently in this text.
4017 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4018 | It contains multiple lines with various patterns.
4019 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4020 | This helps test case-insensitive searching.
4021 | The quick brown fox jumps over the lazy dog.
4022 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4023 | Short patterns like ab should also be findable.
4024 | Single character patterns like 'a' appear frequently in this text.
4025 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4026 | It contains multiple lines with various patterns.
4027 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4028 | This helps test case-insensitive searching.
4029 | The quick brown fox jumps over the lazy dog.
4030 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4031 | Short patterns like ab should also be findable.
4032 | Single character patterns like 'a' appear frequently in this text.
4033 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4034 | It contains multiple lines with various patterns.
4035 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4036 | This helps test case-insensitive searching.
4037 | The quick brown fox jumps over the lazy dog.
4038 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4039 | Short patterns like ab should also be findable.
4040 | Single character patterns like 'a' appear frequently in this text.
4041 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4042 | It contains multiple lines with various patterns.
4043 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4044 | This helps test case-insensitive searching.
4045 | The quick brown fox jumps over the lazy dog.
4046 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4047 | Short patterns like ab should also be findable.
4048 | Single character patterns like 'a' appear frequently in this text.
4049 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4050 | It contains multiple lines with various patterns.
4051 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4052 | This helps test case-insensitive searching.
4053 | The quick brown fox jumps over the lazy dog.
4054 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4055 | Short patterns like ab should also be findable.
4056 | Single character patterns like 'a' appear frequently in this text.
4057 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4058 | It contains multiple lines with various patterns.
4059 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4060 | This helps test case-insensitive searching.
4061 | The quick brown fox jumps over the lazy dog.
4062 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4063 | Short patterns like ab should also be findable.
4064 | Single character patterns like 'a' appear frequently in this text.
4065 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4066 | It contains multiple lines with various patterns.
4067 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4068 | This helps test case-insensitive searching.
4069 | The quick brown fox jumps over the lazy dog.
4070 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4071 | Short patterns like ab should also be findable.
4072 | Single character patterns like 'a' appear frequently in this text.
4073 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4074 | It contains multiple lines with various patterns.
4075 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4076 | This helps test case-insensitive searching.
4077 | The quick brown fox jumps over the lazy dog.
4078 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4079 | Short patterns like ab should also be findable.
4080 | Single character patterns like 'a' appear frequently in this text.
4081 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4082 | It contains multiple lines with various patterns.
4083 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4084 | This helps test case-insensitive searching.
4085 | The quick brown fox jumps over the lazy dog.
4086 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4087 | Short patterns like ab should also be findable.
4088 | Single character patterns like 'a' appear frequently in this text.
4089 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4090 | It contains multiple lines with various patterns.
4091 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4092 | This helps test case-insensitive searching.
4093 | The quick brown fox jumps over the lazy dog.
4094 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4095 | Short patterns like ab should also be findable.
4096 | Single character patterns like 'a' appear frequently in this text.
4097 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4098 | It contains multiple lines with various patterns.
4099 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4100 | This helps test case-insensitive searching.
4101 | The quick brown fox jumps over the lazy dog.
4102 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4103 | Short patterns like ab should also be findable.
4104 | Single character patterns like 'a' appear frequently in this text.
4105 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4106 | It contains multiple lines with various patterns.
4107 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4108 | This helps test case-insensitive searching.
4109 | The quick brown fox jumps over the lazy dog.
4110 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4111 | Short patterns like ab should also be findable.
4112 | Single character patterns like 'a' appear frequently in this text.
4113 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4114 | It contains multiple lines with various patterns.
4115 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4116 | This helps test case-insensitive searching.
4117 | The quick brown fox jumps over the lazy dog.
4118 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4119 | Short patterns like ab should also be findable.
4120 | Single character patterns like 'a' appear frequently in this text.
4121 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4122 | It contains multiple lines with various patterns.
4123 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4124 | This helps test case-insensitive searching.
4125 | The quick brown fox jumps over the lazy dog.
4126 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4127 | Short patterns like ab should also be findable.
4128 | Single character patterns like 'a' appear frequently in this text.
4129 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4130 | It contains multiple lines with various patterns.
4131 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4132 | This helps test case-insensitive searching.
4133 | The quick brown fox jumps over the lazy dog.
4134 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4135 | Short patterns like ab should also be findable.
4136 | Single character patterns like 'a' appear frequently in this text.
4137 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4138 | It contains multiple lines with various patterns.
4139 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4140 | This helps test case-insensitive searching.
4141 | The quick brown fox jumps over the lazy dog.
4142 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4143 | Short patterns like ab should also be findable.
4144 | Single character patterns like 'a' appear frequently in this text.
4145 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4146 | It contains multiple lines with various patterns.
4147 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4148 | This helps test case-insensitive searching.
4149 | The quick brown fox jumps over the lazy dog.
4150 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4151 | Short patterns like ab should also be findable.
4152 | Single character patterns like 'a' appear frequently in this text.
4153 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4154 | It contains multiple lines with various patterns.
4155 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4156 | This helps test case-insensitive searching.
4157 | The quick brown fox jumps over the lazy dog.
4158 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4159 | Short patterns like ab should also be findable.
4160 | Single character patterns like 'a' appear frequently in this text.
4161 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4162 | It contains multiple lines with various patterns.
4163 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4164 | This helps test case-insensitive searching.
4165 | The quick brown fox jumps over the lazy dog.
4166 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4167 | Short patterns like ab should also be findable.
4168 | Single character patterns like 'a' appear frequently in this text.
4169 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4170 | It contains multiple lines with various patterns.
4171 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4172 | This helps test case-insensitive searching.
4173 | The quick brown fox jumps over the lazy dog.
4174 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4175 | Short patterns like ab should also be findable.
4176 | Single character patterns like 'a' appear frequently in this text.
4177 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4178 | It contains multiple lines with various patterns.
4179 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4180 | This helps test case-insensitive searching.
4181 | The quick brown fox jumps over the lazy dog.
4182 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4183 | Short patterns like ab should also be findable.
4184 | Single character patterns like 'a' appear frequently in this text.
4185 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4186 | It contains multiple lines with various patterns.
4187 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4188 | This helps test case-insensitive searching.
4189 | The quick brown fox jumps over the lazy dog.
4190 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4191 | Short patterns like ab should also be findable.
4192 | Single character patterns like 'a' appear frequently in this text.
4193 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4194 | It contains multiple lines with various patterns.
4195 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4196 | This helps test case-insensitive searching.
4197 | The quick brown fox jumps over the lazy dog.
4198 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4199 | Short patterns like ab should also be findable.
4200 | Single character patterns like 'a' appear frequently in this text.
4201 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4202 | It contains multiple lines with various patterns.
4203 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4204 | This helps test case-insensitive searching.
4205 | The quick brown fox jumps over the lazy dog.
4206 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4207 | Short patterns like ab should also be findable.
4208 | Single character patterns like 'a' appear frequently in this text.
4209 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4210 | It contains multiple lines with various patterns.
4211 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4212 | This helps test case-insensitive searching.
4213 | The quick brown fox jumps over the lazy dog.
4214 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4215 | Short patterns like ab should also be findable.
4216 | Single character patterns like 'a' appear frequently in this text.
4217 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4218 | It contains multiple lines with various patterns.
4219 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4220 | This helps test case-insensitive searching.
4221 | The quick brown fox jumps over the lazy dog.
4222 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4223 | Short patterns like ab should also be findable.
4224 | Single character patterns like 'a' appear frequently in this text.
4225 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4226 | It contains multiple lines with various patterns.
4227 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4228 | This helps test case-insensitive searching.
4229 | The quick brown fox jumps over the lazy dog.
4230 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4231 | Short patterns like ab should also be findable.
4232 | Single character patterns like 'a' appear frequently in this text.
4233 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4234 | It contains multiple lines with various patterns.
4235 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4236 | This helps test case-insensitive searching.
4237 | The quick brown fox jumps over the lazy dog.
4238 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4239 | Short patterns like ab should also be findable.
4240 | Single character patterns like 'a' appear frequently in this text.
4241 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4242 | It contains multiple lines with various patterns.
4243 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4244 | This helps test case-insensitive searching.
4245 | The quick brown fox jumps over the lazy dog.
4246 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4247 | Short patterns like ab should also be findable.
4248 | Single character patterns like 'a' appear frequently in this text.
4249 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4250 | It contains multiple lines with various patterns.
4251 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4252 | This helps test case-insensitive searching.
4253 | The quick brown fox jumps over the lazy dog.
4254 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4255 | Short patterns like ab should also be findable.
4256 | Single character patterns like 'a' appear frequently in this text.
4257 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4258 | It contains multiple lines with various patterns.
4259 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4260 | This helps test case-insensitive searching.
4261 | The quick brown fox jumps over the lazy dog.
4262 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4263 | Short patterns like ab should also be findable.
4264 | Single character patterns like 'a' appear frequently in this text.
4265 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4266 | It contains multiple lines with various patterns.
4267 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4268 | This helps test case-insensitive searching.
4269 | The quick brown fox jumps over the lazy dog.
4270 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4271 | Short patterns like ab should also be findable.
4272 | Single character patterns like 'a' appear frequently in this text.
4273 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4274 | It contains multiple lines with various patterns.
4275 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4276 | This helps test case-insensitive searching.
4277 | The quick brown fox jumps over the lazy dog.
4278 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4279 | Short patterns like ab should also be findable.
4280 | Single character patterns like 'a' appear frequently in this text.
4281 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4282 | It contains multiple lines with various patterns.
4283 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4284 | This helps test case-insensitive searching.
4285 | The quick brown fox jumps over the lazy dog.
4286 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4287 | Short patterns like ab should also be findable.
4288 | Single character patterns like 'a' appear frequently in this text.
4289 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4290 | It contains multiple lines with various patterns.
4291 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4292 | This helps test case-insensitive searching.
4293 | The quick brown fox jumps over the lazy dog.
4294 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4295 | Short patterns like ab should also be findable.
4296 | Single character patterns like 'a' appear frequently in this text.
4297 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4298 | It contains multiple lines with various patterns.
4299 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4300 | This helps test case-insensitive searching.
4301 | The quick brown fox jumps over the lazy dog.
4302 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4303 | Short patterns like ab should also be findable.
4304 | Single character patterns like 'a' appear frequently in this text.
4305 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4306 | It contains multiple lines with various patterns.
4307 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4308 | This helps test case-insensitive searching.
4309 | The quick brown fox jumps over the lazy dog.
4310 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4311 | Short patterns like ab should also be findable.
4312 | Single character patterns like 'a' appear frequently in this text.
4313 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4314 | It contains multiple lines with various patterns.
4315 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4316 | This helps test case-insensitive searching.
4317 | The quick brown fox jumps over the lazy dog.
4318 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4319 | Short patterns like ab should also be findable.
4320 | Single character patterns like 'a' appear frequently in this text.
4321 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4322 | It contains multiple lines with various patterns.
4323 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4324 | This helps test case-insensitive searching.
4325 | The quick brown fox jumps over the lazy dog.
4326 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4327 | Short patterns like ab should also be findable.
4328 | Single character patterns like 'a' appear frequently in this text.
4329 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4330 | It contains multiple lines with various patterns.
4331 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4332 | This helps test case-insensitive searching.
4333 | The quick brown fox jumps over the lazy dog.
4334 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4335 | Short patterns like ab should also be findable.
4336 | Single character patterns like 'a' appear frequently in this text.
4337 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4338 | It contains multiple lines with various patterns.
4339 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4340 | This helps test case-insensitive searching.
4341 | The quick brown fox jumps over the lazy dog.
4342 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4343 | Short patterns like ab should also be findable.
4344 | Single character patterns like 'a' appear frequently in this text.
4345 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4346 | It contains multiple lines with various patterns.
4347 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4348 | This helps test case-insensitive searching.
4349 | The quick brown fox jumps over the lazy dog.
4350 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4351 | Short patterns like ab should also be findable.
4352 | Single character patterns like 'a' appear frequently in this text.
4353 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4354 | It contains multiple lines with various patterns.
4355 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4356 | This helps test case-insensitive searching.
4357 | The quick brown fox jumps over the lazy dog.
4358 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4359 | Short patterns like ab should also be findable.
4360 | Single character patterns like 'a' appear frequently in this text.
4361 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4362 | It contains multiple lines with various patterns.
4363 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4364 | This helps test case-insensitive searching.
4365 | The quick brown fox jumps over the lazy dog.
4366 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4367 | Short patterns like ab should also be findable.
4368 | Single character patterns like 'a' appear frequently in this text.
4369 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4370 | It contains multiple lines with various patterns.
4371 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4372 | This helps test case-insensitive searching.
4373 | The quick brown fox jumps over the lazy dog.
4374 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4375 | Short patterns like ab should also be findable.
4376 | Single character patterns like 'a' appear frequently in this text.
4377 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4378 | It contains multiple lines with various patterns.
4379 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4380 | This helps test case-insensitive searching.
4381 | The quick brown fox jumps over the lazy dog.
4382 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4383 | Short patterns like ab should also be findable.
4384 | Single character patterns like 'a' appear frequently in this text.
4385 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4386 | It contains multiple lines with various patterns.
4387 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4388 | This helps test case-insensitive searching.
4389 | The quick brown fox jumps over the lazy dog.
4390 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4391 | Short patterns like ab should also be findable.
4392 | Single character patterns like 'a' appear frequently in this text.
4393 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4394 | It contains multiple lines with various patterns.
4395 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4396 | This helps test case-insensitive searching.
4397 | The quick brown fox jumps over the lazy dog.
4398 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4399 | Short patterns like ab should also be findable.
4400 | Single character patterns like 'a' appear frequently in this text.
4401 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4402 | It contains multiple lines with various patterns.
4403 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4404 | This helps test case-insensitive searching.
4405 | The quick brown fox jumps over the lazy dog.
4406 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4407 | Short patterns like ab should also be findable.
4408 | Single character patterns like 'a' appear frequently in this text.
4409 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4410 | It contains multiple lines with various patterns.
4411 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4412 | This helps test case-insensitive searching.
4413 | The quick brown fox jumps over the lazy dog.
4414 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4415 | Short patterns like ab should also be findable.
4416 | Single character patterns like 'a' appear frequently in this text.
4417 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4418 | It contains multiple lines with various patterns.
4419 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4420 | This helps test case-insensitive searching.
4421 | The quick brown fox jumps over the lazy dog.
4422 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4423 | Short patterns like ab should also be findable.
4424 | Single character patterns like 'a' appear frequently in this text.
4425 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4426 | It contains multiple lines with various patterns.
4427 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4428 | This helps test case-insensitive searching.
4429 | The quick brown fox jumps over the lazy dog.
4430 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4431 | Short patterns like ab should also be findable.
4432 | Single character patterns like 'a' appear frequently in this text.
4433 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4434 | It contains multiple lines with various patterns.
4435 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4436 | This helps test case-insensitive searching.
4437 | The quick brown fox jumps over the lazy dog.
4438 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4439 | Short patterns like ab should also be findable.
4440 | Single character patterns like 'a' appear frequently in this text.
4441 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4442 | It contains multiple lines with various patterns.
4443 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4444 | This helps test case-insensitive searching.
4445 | The quick brown fox jumps over the lazy dog.
4446 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4447 | Short patterns like ab should also be findable.
4448 | Single character patterns like 'a' appear frequently in this text.
4449 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4450 | It contains multiple lines with various patterns.
4451 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4452 | This helps test case-insensitive searching.
4453 | The quick brown fox jumps over the lazy dog.
4454 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4455 | Short patterns like ab should also be findable.
4456 | Single character patterns like 'a' appear frequently in this text.
4457 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4458 | It contains multiple lines with various patterns.
4459 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4460 | This helps test case-insensitive searching.
4461 | The quick brown fox jumps over the lazy dog.
4462 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4463 | Short patterns like ab should also be findable.
4464 | Single character patterns like 'a' appear frequently in this text.
4465 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4466 | It contains multiple lines with various patterns.
4467 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4468 | This helps test case-insensitive searching.
4469 | The quick brown fox jumps over the lazy dog.
4470 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4471 | Short patterns like ab should also be findable.
4472 | Single character patterns like 'a' appear frequently in this text.
4473 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4474 | It contains multiple lines with various patterns.
4475 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4476 | This helps test case-insensitive searching.
4477 | The quick brown fox jumps over the lazy dog.
4478 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4479 | Short patterns like ab should also be findable.
4480 | Single character patterns like 'a' appear frequently in this text.
4481 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4482 | It contains multiple lines with various patterns.
4483 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4484 | This helps test case-insensitive searching.
4485 | The quick brown fox jumps over the lazy dog.
4486 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4487 | Short patterns like ab should also be findable.
4488 | Single character patterns like 'a' appear frequently in this text.
4489 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4490 | It contains multiple lines with various patterns.
4491 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4492 | This helps test case-insensitive searching.
4493 | The quick brown fox jumps over the lazy dog.
4494 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4495 | Short patterns like ab should also be findable.
4496 | Single character patterns like 'a' appear frequently in this text.
4497 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4498 | It contains multiple lines with various patterns.
4499 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4500 | This helps test case-insensitive searching.
4501 | The quick brown fox jumps over the lazy dog.
4502 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4503 | Short patterns like ab should also be findable.
4504 | Single character patterns like 'a' appear frequently in this text.
4505 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4506 | It contains multiple lines with various patterns.
4507 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4508 | This helps test case-insensitive searching.
4509 | The quick brown fox jumps over the lazy dog.
4510 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4511 | Short patterns like ab should also be findable.
4512 | Single character patterns like 'a' appear frequently in this text.
4513 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4514 | It contains multiple lines with various patterns.
4515 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4516 | This helps test case-insensitive searching.
4517 | The quick brown fox jumps over the lazy dog.
4518 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4519 | Short patterns like ab should also be findable.
4520 | Single character patterns like 'a' appear frequently in this text.
4521 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4522 | It contains multiple lines with various patterns.
4523 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4524 | This helps test case-insensitive searching.
4525 | The quick brown fox jumps over the lazy dog.
4526 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4527 | Short patterns like ab should also be findable.
4528 | Single character patterns like 'a' appear frequently in this text.
4529 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4530 | It contains multiple lines with various patterns.
4531 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4532 | This helps test case-insensitive searching.
4533 | The quick brown fox jumps over the lazy dog.
4534 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4535 | Short patterns like ab should also be findable.
4536 | Single character patterns like 'a' appear frequently in this text.
4537 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4538 | It contains multiple lines with various patterns.
4539 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4540 | This helps test case-insensitive searching.
4541 | The quick brown fox jumps over the lazy dog.
4542 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4543 | Short patterns like ab should also be findable.
4544 | Single character patterns like 'a' appear frequently in this text.
4545 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4546 | It contains multiple lines with various patterns.
4547 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4548 | This helps test case-insensitive searching.
4549 | The quick brown fox jumps over the lazy dog.
4550 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4551 | Short patterns like ab should also be findable.
4552 | Single character patterns like 'a' appear frequently in this text.
4553 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4554 | It contains multiple lines with various patterns.
4555 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4556 | This helps test case-insensitive searching.
4557 | The quick brown fox jumps over the lazy dog.
4558 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4559 | Short patterns like ab should also be findable.
4560 | Single character patterns like 'a' appear frequently in this text.
4561 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4562 | It contains multiple lines with various patterns.
4563 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4564 | This helps test case-insensitive searching.
4565 | The quick brown fox jumps over the lazy dog.
4566 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4567 | Short patterns like ab should also be findable.
4568 | Single character patterns like 'a' appear frequently in this text.
4569 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4570 | It contains multiple lines with various patterns.
4571 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4572 | This helps test case-insensitive searching.
4573 | The quick brown fox jumps over the lazy dog.
4574 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4575 | Short patterns like ab should also be findable.
4576 | Single character patterns like 'a' appear frequently in this text.
4577 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4578 | It contains multiple lines with various patterns.
4579 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4580 | This helps test case-insensitive searching.
4581 | The quick brown fox jumps over the lazy dog.
4582 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4583 | Short patterns like ab should also be findable.
4584 | Single character patterns like 'a' appear frequently in this text.
4585 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4586 | It contains multiple lines with various patterns.
4587 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4588 | This helps test case-insensitive searching.
4589 | The quick brown fox jumps over the lazy dog.
4590 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4591 | Short patterns like ab should also be findable.
4592 | Single character patterns like 'a' appear frequently in this text.
4593 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4594 | It contains multiple lines with various patterns.
4595 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4596 | This helps test case-insensitive searching.
4597 | The quick brown fox jumps over the lazy dog.
4598 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4599 | Short patterns like ab should also be findable.
4600 | Single character patterns like 'a' appear frequently in this text.
4601 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4602 | It contains multiple lines with various patterns.
4603 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4604 | This helps test case-insensitive searching.
4605 | The quick brown fox jumps over the lazy dog.
4606 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4607 | Short patterns like ab should also be findable.
4608 | Single character patterns like 'a' appear frequently in this text.
4609 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4610 | It contains multiple lines with various patterns.
4611 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4612 | This helps test case-insensitive searching.
4613 | The quick brown fox jumps over the lazy dog.
4614 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4615 | Short patterns like ab should also be findable.
4616 | Single character patterns like 'a' appear frequently in this text.
4617 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4618 | It contains multiple lines with various patterns.
4619 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4620 | This helps test case-insensitive searching.
4621 | The quick brown fox jumps over the lazy dog.
4622 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4623 | Short patterns like ab should also be findable.
4624 | Single character patterns like 'a' appear frequently in this text.
4625 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4626 | It contains multiple lines with various patterns.
4627 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4628 | This helps test case-insensitive searching.
4629 | The quick brown fox jumps over the lazy dog.
4630 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4631 | Short patterns like ab should also be findable.
4632 | Single character patterns like 'a' appear frequently in this text.
4633 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4634 | It contains multiple lines with various patterns.
4635 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4636 | This helps test case-insensitive searching.
4637 | The quick brown fox jumps over the lazy dog.
4638 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4639 | Short patterns like ab should also be findable.
4640 | Single character patterns like 'a' appear frequently in this text.
4641 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4642 | It contains multiple lines with various patterns.
4643 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4644 | This helps test case-insensitive searching.
4645 | The quick brown fox jumps over the lazy dog.
4646 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4647 | Short patterns like ab should also be findable.
4648 | Single character patterns like 'a' appear frequently in this text.
4649 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4650 | It contains multiple lines with various patterns.
4651 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4652 | This helps test case-insensitive searching.
4653 | The quick brown fox jumps over the lazy dog.
4654 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4655 | Short patterns like ab should also be findable.
4656 | Single character patterns like 'a' appear frequently in this text.
4657 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4658 | It contains multiple lines with various patterns.
4659 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4660 | This helps test case-insensitive searching.
4661 | The quick brown fox jumps over the lazy dog.
4662 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4663 | Short patterns like ab should also be findable.
4664 | Single character patterns like 'a' appear frequently in this text.
4665 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4666 | It contains multiple lines with various patterns.
4667 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4668 | This helps test case-insensitive searching.
4669 | The quick brown fox jumps over the lazy dog.
4670 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4671 | Short patterns like ab should also be findable.
4672 | Single character patterns like 'a' appear frequently in this text.
4673 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4674 | It contains multiple lines with various patterns.
4675 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4676 | This helps test case-insensitive searching.
4677 | The quick brown fox jumps over the lazy dog.
4678 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4679 | Short patterns like ab should also be findable.
4680 | Single character patterns like 'a' appear frequently in this text.
4681 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4682 | It contains multiple lines with various patterns.
4683 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4684 | This helps test case-insensitive searching.
4685 | The quick brown fox jumps over the lazy dog.
4686 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4687 | Short patterns like ab should also be findable.
4688 | Single character patterns like 'a' appear frequently in this text.
4689 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4690 | It contains multiple lines with various patterns.
4691 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4692 | This helps test case-insensitive searching.
4693 | The quick brown fox jumps over the lazy dog.
4694 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4695 | Short patterns like ab should also be findable.
4696 | Single character patterns like 'a' appear frequently in this text.
4697 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4698 | It contains multiple lines with various patterns.
4699 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4700 | This helps test case-insensitive searching.
4701 | The quick brown fox jumps over the lazy dog.
4702 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4703 | Short patterns like ab should also be findable.
4704 | Single character patterns like 'a' appear frequently in this text.
4705 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4706 | It contains multiple lines with various patterns.
4707 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4708 | This helps test case-insensitive searching.
4709 | The quick brown fox jumps over the lazy dog.
4710 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4711 | Short patterns like ab should also be findable.
4712 | Single character patterns like 'a' appear frequently in this text.
4713 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4714 | It contains multiple lines with various patterns.
4715 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4716 | This helps test case-insensitive searching.
4717 | The quick brown fox jumps over the lazy dog.
4718 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4719 | Short patterns like ab should also be findable.
4720 | Single character patterns like 'a' appear frequently in this text.
4721 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4722 | It contains multiple lines with various patterns.
4723 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4724 | This helps test case-insensitive searching.
4725 | The quick brown fox jumps over the lazy dog.
4726 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4727 | Short patterns like ab should also be findable.
4728 | Single character patterns like 'a' appear frequently in this text.
4729 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4730 | It contains multiple lines with various patterns.
4731 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4732 | This helps test case-insensitive searching.
4733 | The quick brown fox jumps over the lazy dog.
4734 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4735 | Short patterns like ab should also be findable.
4736 | Single character patterns like 'a' appear frequently in this text.
4737 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4738 | It contains multiple lines with various patterns.
4739 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4740 | This helps test case-insensitive searching.
4741 | The quick brown fox jumps over the lazy dog.
4742 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4743 | Short patterns like ab should also be findable.
4744 | Single character patterns like 'a' appear frequently in this text.
4745 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4746 | It contains multiple lines with various patterns.
4747 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4748 | This helps test case-insensitive searching.
4749 | The quick brown fox jumps over the lazy dog.
4750 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4751 | Short patterns like ab should also be findable.
4752 | Single character patterns like 'a' appear frequently in this text.
4753 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4754 | It contains multiple lines with various patterns.
4755 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4756 | This helps test case-insensitive searching.
4757 | The quick brown fox jumps over the lazy dog.
4758 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4759 | Short patterns like ab should also be findable.
4760 | Single character patterns like 'a' appear frequently in this text.
4761 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4762 | It contains multiple lines with various patterns.
4763 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4764 | This helps test case-insensitive searching.
4765 | The quick brown fox jumps over the lazy dog.
4766 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4767 | Short patterns like ab should also be findable.
4768 | Single character patterns like 'a' appear frequently in this text.
4769 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4770 | It contains multiple lines with various patterns.
4771 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4772 | This helps test case-insensitive searching.
4773 | The quick brown fox jumps over the lazy dog.
4774 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4775 | Short patterns like ab should also be findable.
4776 | Single character patterns like 'a' appear frequently in this text.
4777 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4778 | It contains multiple lines with various patterns.
4779 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4780 | This helps test case-insensitive searching.
4781 | The quick brown fox jumps over the lazy dog.
4782 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4783 | Short patterns like ab should also be findable.
4784 | Single character patterns like 'a' appear frequently in this text.
4785 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4786 | It contains multiple lines with various patterns.
4787 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4788 | This helps test case-insensitive searching.
4789 | The quick brown fox jumps over the lazy dog.
4790 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4791 | Short patterns like ab should also be findable.
4792 | Single character patterns like 'a' appear frequently in this text.
4793 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4794 | It contains multiple lines with various patterns.
4795 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4796 | This helps test case-insensitive searching.
4797 | The quick brown fox jumps over the lazy dog.
4798 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4799 | Short patterns like ab should also be findable.
4800 | Single character patterns like 'a' appear frequently in this text.
4801 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4802 | It contains multiple lines with various patterns.
4803 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4804 | This helps test case-insensitive searching.
4805 | The quick brown fox jumps over the lazy dog.
4806 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4807 | Short patterns like ab should also be findable.
4808 | Single character patterns like 'a' appear frequently in this text.
4809 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4810 | It contains multiple lines with various patterns.
4811 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4812 | This helps test case-insensitive searching.
4813 | The quick brown fox jumps over the lazy dog.
4814 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4815 | Short patterns like ab should also be findable.
4816 | Single character patterns like 'a' appear frequently in this text.
4817 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4818 | It contains multiple lines with various patterns.
4819 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4820 | This helps test case-insensitive searching.
4821 | The quick brown fox jumps over the lazy dog.
4822 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4823 | Short patterns like ab should also be findable.
4824 | Single character patterns like 'a' appear frequently in this text.
4825 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4826 | It contains multiple lines with various patterns.
4827 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4828 | This helps test case-insensitive searching.
4829 | The quick brown fox jumps over the lazy dog.
4830 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4831 | Short patterns like ab should also be findable.
4832 | Single character patterns like 'a' appear frequently in this text.
4833 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4834 | It contains multiple lines with various patterns.
4835 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4836 | This helps test case-insensitive searching.
4837 | The quick brown fox jumps over the lazy dog.
4838 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4839 | Short patterns like ab should also be findable.
4840 | Single character patterns like 'a' appear frequently in this text.
4841 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4842 | It contains multiple lines with various patterns.
4843 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4844 | This helps test case-insensitive searching.
4845 | The quick brown fox jumps over the lazy dog.
4846 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4847 | Short patterns like ab should also be findable.
4848 | Single character patterns like 'a' appear frequently in this text.
4849 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4850 | It contains multiple lines with various patterns.
4851 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4852 | This helps test case-insensitive searching.
4853 | The quick brown fox jumps over the lazy dog.
4854 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4855 | Short patterns like ab should also be findable.
4856 | Single character patterns like 'a' appear frequently in this text.
4857 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4858 | It contains multiple lines with various patterns.
4859 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4860 | This helps test case-insensitive searching.
4861 | The quick brown fox jumps over the lazy dog.
4862 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4863 | Short patterns like ab should also be findable.
4864 | Single character patterns like 'a' appear frequently in this text.
4865 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4866 | It contains multiple lines with various patterns.
4867 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4868 | This helps test case-insensitive searching.
4869 | The quick brown fox jumps over the lazy dog.
4870 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4871 | Short patterns like ab should also be findable.
4872 | Single character patterns like 'a' appear frequently in this text.
4873 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4874 | It contains multiple lines with various patterns.
4875 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4876 | This helps test case-insensitive searching.
4877 | The quick brown fox jumps over the lazy dog.
4878 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4879 | Short patterns like ab should also be findable.
4880 | Single character patterns like 'a' appear frequently in this text.
4881 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4882 | It contains multiple lines with various patterns.
4883 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4884 | This helps test case-insensitive searching.
4885 | The quick brown fox jumps over the lazy dog.
4886 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4887 | Short patterns like ab should also be findable.
4888 | Single character patterns like 'a' appear frequently in this text.
4889 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4890 | It contains multiple lines with various patterns.
4891 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4892 | This helps test case-insensitive searching.
4893 | The quick brown fox jumps over the lazy dog.
4894 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4895 | Short patterns like ab should also be findable.
4896 | Single character patterns like 'a' appear frequently in this text.
4897 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4898 | It contains multiple lines with various patterns.
4899 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4900 | This helps test case-insensitive searching.
4901 | The quick brown fox jumps over the lazy dog.
4902 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4903 | Short patterns like ab should also be findable.
4904 | Single character patterns like 'a' appear frequently in this text.
4905 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4906 | It contains multiple lines with various patterns.
4907 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4908 | This helps test case-insensitive searching.
4909 | The quick brown fox jumps over the lazy dog.
4910 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4911 | Short patterns like ab should also be findable.
4912 | Single character patterns like 'a' appear frequently in this text.
4913 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4914 | It contains multiple lines with various patterns.
4915 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4916 | This helps test case-insensitive searching.
4917 | The quick brown fox jumps over the lazy dog.
4918 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4919 | Short patterns like ab should also be findable.
4920 | Single character patterns like 'a' appear frequently in this text.
4921 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4922 | It contains multiple lines with various patterns.
4923 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4924 | This helps test case-insensitive searching.
4925 | The quick brown fox jumps over the lazy dog.
4926 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4927 | Short patterns like ab should also be findable.
4928 | Single character patterns like 'a' appear frequently in this text.
4929 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4930 | It contains multiple lines with various patterns.
4931 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4932 | This helps test case-insensitive searching.
4933 | The quick brown fox jumps over the lazy dog.
4934 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4935 | Short patterns like ab should also be findable.
4936 | Single character patterns like 'a' appear frequently in this text.
4937 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4938 | It contains multiple lines with various patterns.
4939 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4940 | This helps test case-insensitive searching.
4941 | The quick brown fox jumps over the lazy dog.
4942 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4943 | Short patterns like ab should also be findable.
4944 | Single character patterns like 'a' appear frequently in this text.
4945 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4946 | It contains multiple lines with various patterns.
4947 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4948 | This helps test case-insensitive searching.
4949 | The quick brown fox jumps over the lazy dog.
4950 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4951 | Short patterns like ab should also be findable.
4952 | Single character patterns like 'a' appear frequently in this text.
4953 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4954 | It contains multiple lines with various patterns.
4955 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4956 | This helps test case-insensitive searching.
4957 | The quick brown fox jumps over the lazy dog.
4958 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4959 | Short patterns like ab should also be findable.
4960 | Single character patterns like 'a' appear frequently in this text.
4961 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4962 | It contains multiple lines with various patterns.
4963 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4964 | This helps test case-insensitive searching.
4965 | The quick brown fox jumps over the lazy dog.
4966 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4967 | Short patterns like ab should also be findable.
4968 | Single character patterns like 'a' appear frequently in this text.
4969 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4970 | It contains multiple lines with various patterns.
4971 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4972 | This helps test case-insensitive searching.
4973 | The quick brown fox jumps over the lazy dog.
4974 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4975 | Short patterns like ab should also be findable.
4976 | Single character patterns like 'a' appear frequently in this text.
4977 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4978 | It contains multiple lines with various patterns.
4979 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4980 | This helps test case-insensitive searching.
4981 | The quick brown fox jumps over the lazy dog.
4982 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4983 | Short patterns like ab should also be findable.
4984 | Single character patterns like 'a' appear frequently in this text.
4985 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4986 | It contains multiple lines with various patterns.
4987 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4988 | This helps test case-insensitive searching.
4989 | The quick brown fox jumps over the lazy dog.
4990 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4991 | Short patterns like ab should also be findable.
4992 | Single character patterns like 'a' appear frequently in this text.
4993 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
4994 | It contains multiple lines with various patterns.
4995 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
4996 | This helps test case-insensitive searching.
4997 | The quick brown fox jumps over the lazy dog.
4998 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
4999 | Short patterns like ab should also be findable.
5000 | Single character patterns like 'a' appear frequently in this text.
5001 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5002 | It contains multiple lines with various patterns.
5003 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5004 | This helps test case-insensitive searching.
5005 | The quick brown fox jumps over the lazy dog.
5006 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5007 | Short patterns like ab should also be findable.
5008 | Single character patterns like 'a' appear frequently in this text.
5009 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5010 | It contains multiple lines with various patterns.
5011 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5012 | This helps test case-insensitive searching.
5013 | The quick brown fox jumps over the lazy dog.
5014 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5015 | Short patterns like ab should also be findable.
5016 | Single character patterns like 'a' appear frequently in this text.
5017 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5018 | It contains multiple lines with various patterns.
5019 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5020 | This helps test case-insensitive searching.
5021 | The quick brown fox jumps over the lazy dog.
5022 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5023 | Short patterns like ab should also be findable.
5024 | Single character patterns like 'a' appear frequently in this text.
5025 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5026 | It contains multiple lines with various patterns.
5027 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5028 | This helps test case-insensitive searching.
5029 | The quick brown fox jumps over the lazy dog.
5030 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5031 | Short patterns like ab should also be findable.
5032 | Single character patterns like 'a' appear frequently in this text.
5033 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5034 | It contains multiple lines with various patterns.
5035 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5036 | This helps test case-insensitive searching.
5037 | The quick brown fox jumps over the lazy dog.
5038 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5039 | Short patterns like ab should also be findable.
5040 | Single character patterns like 'a' appear frequently in this text.
5041 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5042 | It contains multiple lines with various patterns.
5043 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5044 | This helps test case-insensitive searching.
5045 | The quick brown fox jumps over the lazy dog.
5046 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5047 | Short patterns like ab should also be findable.
5048 | Single character patterns like 'a' appear frequently in this text.
5049 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5050 | It contains multiple lines with various patterns.
5051 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5052 | This helps test case-insensitive searching.
5053 | The quick brown fox jumps over the lazy dog.
5054 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5055 | Short patterns like ab should also be findable.
5056 | Single character patterns like 'a' appear frequently in this text.
5057 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5058 | It contains multiple lines with various patterns.
5059 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5060 | This helps test case-insensitive searching.
5061 | The quick brown fox jumps over the lazy dog.
5062 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5063 | Short patterns like ab should also be findable.
5064 | Single character patterns like 'a' appear frequently in this text.
5065 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5066 | It contains multiple lines with various patterns.
5067 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5068 | This helps test case-insensitive searching.
5069 | The quick brown fox jumps over the lazy dog.
5070 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5071 | Short patterns like ab should also be findable.
5072 | Single character patterns like 'a' appear frequently in this text.
5073 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5074 | It contains multiple lines with various patterns.
5075 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5076 | This helps test case-insensitive searching.
5077 | The quick brown fox jumps over the lazy dog.
5078 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5079 | Short patterns like ab should also be findable.
5080 | Single character patterns like 'a' appear frequently in this text.
5081 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5082 | It contains multiple lines with various patterns.
5083 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5084 | This helps test case-insensitive searching.
5085 | The quick brown fox jumps over the lazy dog.
5086 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5087 | Short patterns like ab should also be findable.
5088 | Single character patterns like 'a' appear frequently in this text.
5089 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5090 | It contains multiple lines with various patterns.
5091 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5092 | This helps test case-insensitive searching.
5093 | The quick brown fox jumps over the lazy dog.
5094 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5095 | Short patterns like ab should also be findable.
5096 | Single character patterns like 'a' appear frequently in this text.
5097 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5098 | It contains multiple lines with various patterns.
5099 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5100 | This helps test case-insensitive searching.
5101 | The quick brown fox jumps over the lazy dog.
5102 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5103 | Short patterns like ab should also be findable.
5104 | Single character patterns like 'a' appear frequently in this text.
5105 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5106 | It contains multiple lines with various patterns.
5107 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5108 | This helps test case-insensitive searching.
5109 | The quick brown fox jumps over the lazy dog.
5110 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5111 | Short patterns like ab should also be findable.
5112 | Single character patterns like 'a' appear frequently in this text.
5113 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5114 | It contains multiple lines with various patterns.
5115 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5116 | This helps test case-insensitive searching.
5117 | The quick brown fox jumps over the lazy dog.
5118 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5119 | Short patterns like ab should also be findable.
5120 | Single character patterns like 'a' appear frequently in this text.
5121 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5122 | It contains multiple lines with various patterns.
5123 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5124 | This helps test case-insensitive searching.
5125 | The quick brown fox jumps over the lazy dog.
5126 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5127 | Short patterns like ab should also be findable.
5128 | Single character patterns like 'a' appear frequently in this text.
5129 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5130 | It contains multiple lines with various patterns.
5131 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5132 | This helps test case-insensitive searching.
5133 | The quick brown fox jumps over the lazy dog.
5134 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5135 | Short patterns like ab should also be findable.
5136 | Single character patterns like 'a' appear frequently in this text.
5137 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5138 | It contains multiple lines with various patterns.
5139 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5140 | This helps test case-insensitive searching.
5141 | The quick brown fox jumps over the lazy dog.
5142 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5143 | Short patterns like ab should also be findable.
5144 | Single character patterns like 'a' appear frequently in this text.
5145 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5146 | It contains multiple lines with various patterns.
5147 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5148 | This helps test case-insensitive searching.
5149 | The quick brown fox jumps over the lazy dog.
5150 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5151 | Short patterns like ab should also be findable.
5152 | Single character patterns like 'a' appear frequently in this text.
5153 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5154 | It contains multiple lines with various patterns.
5155 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5156 | This helps test case-insensitive searching.
5157 | The quick brown fox jumps over the lazy dog.
5158 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5159 | Short patterns like ab should also be findable.
5160 | Single character patterns like 'a' appear frequently in this text.
5161 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5162 | It contains multiple lines with various patterns.
5163 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5164 | This helps test case-insensitive searching.
5165 | The quick brown fox jumps over the lazy dog.
5166 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5167 | Short patterns like ab should also be findable.
5168 | Single character patterns like 'a' appear frequently in this text.
5169 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5170 | It contains multiple lines with various patterns.
5171 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5172 | This helps test case-insensitive searching.
5173 | The quick brown fox jumps over the lazy dog.
5174 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5175 | Short patterns like ab should also be findable.
5176 | Single character patterns like 'a' appear frequently in this text.
5177 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5178 | It contains multiple lines with various patterns.
5179 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5180 | This helps test case-insensitive searching.
5181 | The quick brown fox jumps over the lazy dog.
5182 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5183 | Short patterns like ab should also be findable.
5184 | Single character patterns like 'a' appear frequently in this text.
5185 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5186 | It contains multiple lines with various patterns.
5187 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5188 | This helps test case-insensitive searching.
5189 | The quick brown fox jumps over the lazy dog.
5190 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5191 | Short patterns like ab should also be findable.
5192 | Single character patterns like 'a' appear frequently in this text.
5193 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5194 | It contains multiple lines with various patterns.
5195 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5196 | This helps test case-insensitive searching.
5197 | The quick brown fox jumps over the lazy dog.
5198 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5199 | Short patterns like ab should also be findable.
5200 | Single character patterns like 'a' appear frequently in this text.
5201 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5202 | It contains multiple lines with various patterns.
5203 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5204 | This helps test case-insensitive searching.
5205 | The quick brown fox jumps over the lazy dog.
5206 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5207 | Short patterns like ab should also be findable.
5208 | Single character patterns like 'a' appear frequently in this text.
5209 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5210 | It contains multiple lines with various patterns.
5211 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5212 | This helps test case-insensitive searching.
5213 | The quick brown fox jumps over the lazy dog.
5214 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5215 | Short patterns like ab should also be findable.
5216 | Single character patterns like 'a' appear frequently in this text.
5217 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5218 | It contains multiple lines with various patterns.
5219 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5220 | This helps test case-insensitive searching.
5221 | The quick brown fox jumps over the lazy dog.
5222 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5223 | Short patterns like ab should also be findable.
5224 | Single character patterns like 'a' appear frequently in this text.
5225 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5226 | It contains multiple lines with various patterns.
5227 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5228 | This helps test case-insensitive searching.
5229 | The quick brown fox jumps over the lazy dog.
5230 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5231 | Short patterns like ab should also be findable.
5232 | Single character patterns like 'a' appear frequently in this text.
5233 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5234 | It contains multiple lines with various patterns.
5235 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5236 | This helps test case-insensitive searching.
5237 | The quick brown fox jumps over the lazy dog.
5238 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5239 | Short patterns like ab should also be findable.
5240 | Single character patterns like 'a' appear frequently in this text.
5241 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5242 | It contains multiple lines with various patterns.
5243 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5244 | This helps test case-insensitive searching.
5245 | The quick brown fox jumps over the lazy dog.
5246 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5247 | Short patterns like ab should also be findable.
5248 | Single character patterns like 'a' appear frequently in this text.
5249 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5250 | It contains multiple lines with various patterns.
5251 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5252 | This helps test case-insensitive searching.
5253 | The quick brown fox jumps over the lazy dog.
5254 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5255 | Short patterns like ab should also be findable.
5256 | Single character patterns like 'a' appear frequently in this text.
5257 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5258 | It contains multiple lines with various patterns.
5259 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5260 | This helps test case-insensitive searching.
5261 | The quick brown fox jumps over the lazy dog.
5262 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5263 | Short patterns like ab should also be findable.
5264 | Single character patterns like 'a' appear frequently in this text.
5265 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5266 | It contains multiple lines with various patterns.
5267 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5268 | This helps test case-insensitive searching.
5269 | The quick brown fox jumps over the lazy dog.
5270 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5271 | Short patterns like ab should also be findable.
5272 | Single character patterns like 'a' appear frequently in this text.
5273 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5274 | It contains multiple lines with various patterns.
5275 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5276 | This helps test case-insensitive searching.
5277 | The quick brown fox jumps over the lazy dog.
5278 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5279 | Short patterns like ab should also be findable.
5280 | Single character patterns like 'a' appear frequently in this text.
5281 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5282 | It contains multiple lines with various patterns.
5283 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5284 | This helps test case-insensitive searching.
5285 | The quick brown fox jumps over the lazy dog.
5286 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5287 | Short patterns like ab should also be findable.
5288 | Single character patterns like 'a' appear frequently in this text.
5289 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5290 | It contains multiple lines with various patterns.
5291 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5292 | This helps test case-insensitive searching.
5293 | The quick brown fox jumps over the lazy dog.
5294 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5295 | Short patterns like ab should also be findable.
5296 | Single character patterns like 'a' appear frequently in this text.
5297 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5298 | It contains multiple lines with various patterns.
5299 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5300 | This helps test case-insensitive searching.
5301 | The quick brown fox jumps over the lazy dog.
5302 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5303 | Short patterns like ab should also be findable.
5304 | Single character patterns like 'a' appear frequently in this text.
5305 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5306 | It contains multiple lines with various patterns.
5307 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5308 | This helps test case-insensitive searching.
5309 | The quick brown fox jumps over the lazy dog.
5310 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5311 | Short patterns like ab should also be findable.
5312 | Single character patterns like 'a' appear frequently in this text.
5313 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5314 | It contains multiple lines with various patterns.
5315 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5316 | This helps test case-insensitive searching.
5317 | The quick brown fox jumps over the lazy dog.
5318 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5319 | Short patterns like ab should also be findable.
5320 | Single character patterns like 'a' appear frequently in this text.
5321 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5322 | It contains multiple lines with various patterns.
5323 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5324 | This helps test case-insensitive searching.
5325 | The quick brown fox jumps over the lazy dog.
5326 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5327 | Short patterns like ab should also be findable.
5328 | Single character patterns like 'a' appear frequently in this text.
5329 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5330 | It contains multiple lines with various patterns.
5331 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5332 | This helps test case-insensitive searching.
5333 | The quick brown fox jumps over the lazy dog.
5334 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5335 | Short patterns like ab should also be findable.
5336 | Single character patterns like 'a' appear frequently in this text.
5337 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5338 | It contains multiple lines with various patterns.
5339 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5340 | This helps test case-insensitive searching.
5341 | The quick brown fox jumps over the lazy dog.
5342 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5343 | Short patterns like ab should also be findable.
5344 | Single character patterns like 'a' appear frequently in this text.
5345 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5346 | It contains multiple lines with various patterns.
5347 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5348 | This helps test case-insensitive searching.
5349 | The quick brown fox jumps over the lazy dog.
5350 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5351 | Short patterns like ab should also be findable.
5352 | Single character patterns like 'a' appear frequently in this text.
5353 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5354 | It contains multiple lines with various patterns.
5355 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5356 | This helps test case-insensitive searching.
5357 | The quick brown fox jumps over the lazy dog.
5358 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5359 | Short patterns like ab should also be findable.
5360 | Single character patterns like 'a' appear frequently in this text.
5361 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5362 | It contains multiple lines with various patterns.
5363 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5364 | This helps test case-insensitive searching.
5365 | The quick brown fox jumps over the lazy dog.
5366 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5367 | Short patterns like ab should also be findable.
5368 | Single character patterns like 'a' appear frequently in this text.
5369 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5370 | It contains multiple lines with various patterns.
5371 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5372 | This helps test case-insensitive searching.
5373 | The quick brown fox jumps over the lazy dog.
5374 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5375 | Short patterns like ab should also be findable.
5376 | Single character patterns like 'a' appear frequently in this text.
5377 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5378 | It contains multiple lines with various patterns.
5379 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5380 | This helps test case-insensitive searching.
5381 | The quick brown fox jumps over the lazy dog.
5382 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5383 | Short patterns like ab should also be findable.
5384 | Single character patterns like 'a' appear frequently in this text.
5385 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5386 | It contains multiple lines with various patterns.
5387 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5388 | This helps test case-insensitive searching.
5389 | The quick brown fox jumps over the lazy dog.
5390 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5391 | Short patterns like ab should also be findable.
5392 | Single character patterns like 'a' appear frequently in this text.
5393 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5394 | It contains multiple lines with various patterns.
5395 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5396 | This helps test case-insensitive searching.
5397 | The quick brown fox jumps over the lazy dog.
5398 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5399 | Short patterns like ab should also be findable.
5400 | Single character patterns like 'a' appear frequently in this text.
5401 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5402 | It contains multiple lines with various patterns.
5403 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5404 | This helps test case-insensitive searching.
5405 | The quick brown fox jumps over the lazy dog.
5406 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5407 | Short patterns like ab should also be findable.
5408 | Single character patterns like 'a' appear frequently in this text.
5409 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5410 | It contains multiple lines with various patterns.
5411 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5412 | This helps test case-insensitive searching.
5413 | The quick brown fox jumps over the lazy dog.
5414 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5415 | Short patterns like ab should also be findable.
5416 | Single character patterns like 'a' appear frequently in this text.
5417 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5418 | It contains multiple lines with various patterns.
5419 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5420 | This helps test case-insensitive searching.
5421 | The quick brown fox jumps over the lazy dog.
5422 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5423 | Short patterns like ab should also be findable.
5424 | Single character patterns like 'a' appear frequently in this text.
5425 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5426 | It contains multiple lines with various patterns.
5427 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5428 | This helps test case-insensitive searching.
5429 | The quick brown fox jumps over the lazy dog.
5430 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5431 | Short patterns like ab should also be findable.
5432 | Single character patterns like 'a' appear frequently in this text.
5433 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5434 | It contains multiple lines with various patterns.
5435 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5436 | This helps test case-insensitive searching.
5437 | The quick brown fox jumps over the lazy dog.
5438 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5439 | Short patterns like ab should also be findable.
5440 | Single character patterns like 'a' appear frequently in this text.
5441 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5442 | It contains multiple lines with various patterns.
5443 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5444 | This helps test case-insensitive searching.
5445 | The quick brown fox jumps over the lazy dog.
5446 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5447 | Short patterns like ab should also be findable.
5448 | Single character patterns like 'a' appear frequently in this text.
5449 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5450 | It contains multiple lines with various patterns.
5451 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5452 | This helps test case-insensitive searching.
5453 | The quick brown fox jumps over the lazy dog.
5454 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5455 | Short patterns like ab should also be findable.
5456 | Single character patterns like 'a' appear frequently in this text.
5457 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5458 | It contains multiple lines with various patterns.
5459 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5460 | This helps test case-insensitive searching.
5461 | The quick brown fox jumps over the lazy dog.
5462 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5463 | Short patterns like ab should also be findable.
5464 | Single character patterns like 'a' appear frequently in this text.
5465 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5466 | It contains multiple lines with various patterns.
5467 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5468 | This helps test case-insensitive searching.
5469 | The quick brown fox jumps over the lazy dog.
5470 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5471 | Short patterns like ab should also be findable.
5472 | Single character patterns like 'a' appear frequently in this text.
5473 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5474 | It contains multiple lines with various patterns.
5475 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5476 | This helps test case-insensitive searching.
5477 | The quick brown fox jumps over the lazy dog.
5478 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5479 | Short patterns like ab should also be findable.
5480 | Single character patterns like 'a' appear frequently in this text.
5481 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5482 | It contains multiple lines with various patterns.
5483 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5484 | This helps test case-insensitive searching.
5485 | The quick brown fox jumps over the lazy dog.
5486 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5487 | Short patterns like ab should also be findable.
5488 | Single character patterns like 'a' appear frequently in this text.
5489 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5490 | It contains multiple lines with various patterns.
5491 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5492 | This helps test case-insensitive searching.
5493 | The quick brown fox jumps over the lazy dog.
5494 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5495 | Short patterns like ab should also be findable.
5496 | Single character patterns like 'a' appear frequently in this text.
5497 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5498 | It contains multiple lines with various patterns.
5499 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5500 | This helps test case-insensitive searching.
5501 | The quick brown fox jumps over the lazy dog.
5502 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5503 | Short patterns like ab should also be findable.
5504 | Single character patterns like 'a' appear frequently in this text.
5505 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5506 | It contains multiple lines with various patterns.
5507 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5508 | This helps test case-insensitive searching.
5509 | The quick brown fox jumps over the lazy dog.
5510 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5511 | Short patterns like ab should also be findable.
5512 | Single character patterns like 'a' appear frequently in this text.
5513 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5514 | It contains multiple lines with various patterns.
5515 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5516 | This helps test case-insensitive searching.
5517 | The quick brown fox jumps over the lazy dog.
5518 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5519 | Short patterns like ab should also be findable.
5520 | Single character patterns like 'a' appear frequently in this text.
5521 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5522 | It contains multiple lines with various patterns.
5523 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5524 | This helps test case-insensitive searching.
5525 | The quick brown fox jumps over the lazy dog.
5526 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5527 | Short patterns like ab should also be findable.
5528 | Single character patterns like 'a' appear frequently in this text.
5529 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5530 | It contains multiple lines with various patterns.
5531 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5532 | This helps test case-insensitive searching.
5533 | The quick brown fox jumps over the lazy dog.
5534 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5535 | Short patterns like ab should also be findable.
5536 | Single character patterns like 'a' appear frequently in this text.
5537 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5538 | It contains multiple lines with various patterns.
5539 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5540 | This helps test case-insensitive searching.
5541 | The quick brown fox jumps over the lazy dog.
5542 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5543 | Short patterns like ab should also be findable.
5544 | Single character patterns like 'a' appear frequently in this text.
5545 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5546 | It contains multiple lines with various patterns.
5547 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5548 | This helps test case-insensitive searching.
5549 | The quick brown fox jumps over the lazy dog.
5550 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5551 | Short patterns like ab should also be findable.
5552 | Single character patterns like 'a' appear frequently in this text.
5553 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5554 | It contains multiple lines with various patterns.
5555 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5556 | This helps test case-insensitive searching.
5557 | The quick brown fox jumps over the lazy dog.
5558 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5559 | Short patterns like ab should also be findable.
5560 | Single character patterns like 'a' appear frequently in this text.
5561 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5562 | It contains multiple lines with various patterns.
5563 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5564 | This helps test case-insensitive searching.
5565 | The quick brown fox jumps over the lazy dog.
5566 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5567 | Short patterns like ab should also be findable.
5568 | Single character patterns like 'a' appear frequently in this text.
5569 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5570 | It contains multiple lines with various patterns.
5571 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5572 | This helps test case-insensitive searching.
5573 | The quick brown fox jumps over the lazy dog.
5574 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5575 | Short patterns like ab should also be findable.
5576 | Single character patterns like 'a' appear frequently in this text.
5577 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5578 | It contains multiple lines with various patterns.
5579 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5580 | This helps test case-insensitive searching.
5581 | The quick brown fox jumps over the lazy dog.
5582 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5583 | Short patterns like ab should also be findable.
5584 | Single character patterns like 'a' appear frequently in this text.
5585 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5586 | It contains multiple lines with various patterns.
5587 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5588 | This helps test case-insensitive searching.
5589 | The quick brown fox jumps over the lazy dog.
5590 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5591 | Short patterns like ab should also be findable.
5592 | Single character patterns like 'a' appear frequently in this text.
5593 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5594 | It contains multiple lines with various patterns.
5595 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5596 | This helps test case-insensitive searching.
5597 | The quick brown fox jumps over the lazy dog.
5598 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5599 | Short patterns like ab should also be findable.
5600 | Single character patterns like 'a' appear frequently in this text.
5601 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5602 | It contains multiple lines with various patterns.
5603 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5604 | This helps test case-insensitive searching.
5605 | The quick brown fox jumps over the lazy dog.
5606 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5607 | Short patterns like ab should also be findable.
5608 | Single character patterns like 'a' appear frequently in this text.
5609 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5610 | It contains multiple lines with various patterns.
5611 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5612 | This helps test case-insensitive searching.
5613 | The quick brown fox jumps over the lazy dog.
5614 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5615 | Short patterns like ab should also be findable.
5616 | Single character patterns like 'a' appear frequently in this text.
5617 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5618 | It contains multiple lines with various patterns.
5619 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5620 | This helps test case-insensitive searching.
5621 | The quick brown fox jumps over the lazy dog.
5622 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5623 | Short patterns like ab should also be findable.
5624 | Single character patterns like 'a' appear frequently in this text.
5625 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5626 | It contains multiple lines with various patterns.
5627 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5628 | This helps test case-insensitive searching.
5629 | The quick brown fox jumps over the lazy dog.
5630 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5631 | Short patterns like ab should also be findable.
5632 | Single character patterns like 'a' appear frequently in this text.
5633 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5634 | It contains multiple lines with various patterns.
5635 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5636 | This helps test case-insensitive searching.
5637 | The quick brown fox jumps over the lazy dog.
5638 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5639 | Short patterns like ab should also be findable.
5640 | Single character patterns like 'a' appear frequently in this text.
5641 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5642 | It contains multiple lines with various patterns.
5643 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5644 | This helps test case-insensitive searching.
5645 | The quick brown fox jumps over the lazy dog.
5646 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5647 | Short patterns like ab should also be findable.
5648 | Single character patterns like 'a' appear frequently in this text.
5649 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5650 | It contains multiple lines with various patterns.
5651 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5652 | This helps test case-insensitive searching.
5653 | The quick brown fox jumps over the lazy dog.
5654 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5655 | Short patterns like ab should also be findable.
5656 | Single character patterns like 'a' appear frequently in this text.
5657 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5658 | It contains multiple lines with various patterns.
5659 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5660 | This helps test case-insensitive searching.
5661 | The quick brown fox jumps over the lazy dog.
5662 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5663 | Short patterns like ab should also be findable.
5664 | Single character patterns like 'a' appear frequently in this text.
5665 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5666 | It contains multiple lines with various patterns.
5667 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5668 | This helps test case-insensitive searching.
5669 | The quick brown fox jumps over the lazy dog.
5670 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5671 | Short patterns like ab should also be findable.
5672 | Single character patterns like 'a' appear frequently in this text.
5673 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5674 | It contains multiple lines with various patterns.
5675 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5676 | This helps test case-insensitive searching.
5677 | The quick brown fox jumps over the lazy dog.
5678 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5679 | Short patterns like ab should also be findable.
5680 | Single character patterns like 'a' appear frequently in this text.
5681 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5682 | It contains multiple lines with various patterns.
5683 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5684 | This helps test case-insensitive searching.
5685 | The quick brown fox jumps over the lazy dog.
5686 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5687 | Short patterns like ab should also be findable.
5688 | Single character patterns like 'a' appear frequently in this text.
5689 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5690 | It contains multiple lines with various patterns.
5691 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5692 | This helps test case-insensitive searching.
5693 | The quick brown fox jumps over the lazy dog.
5694 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5695 | Short patterns like ab should also be findable.
5696 | Single character patterns like 'a' appear frequently in this text.
5697 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5698 | It contains multiple lines with various patterns.
5699 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5700 | This helps test case-insensitive searching.
5701 | The quick brown fox jumps over the lazy dog.
5702 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5703 | Short patterns like ab should also be findable.
5704 | Single character patterns like 'a' appear frequently in this text.
5705 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5706 | It contains multiple lines with various patterns.
5707 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5708 | This helps test case-insensitive searching.
5709 | The quick brown fox jumps over the lazy dog.
5710 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5711 | Short patterns like ab should also be findable.
5712 | Single character patterns like 'a' appear frequently in this text.
5713 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5714 | It contains multiple lines with various patterns.
5715 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5716 | This helps test case-insensitive searching.
5717 | The quick brown fox jumps over the lazy dog.
5718 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5719 | Short patterns like ab should also be findable.
5720 | Single character patterns like 'a' appear frequently in this text.
5721 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5722 | It contains multiple lines with various patterns.
5723 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5724 | This helps test case-insensitive searching.
5725 | The quick brown fox jumps over the lazy dog.
5726 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5727 | Short patterns like ab should also be findable.
5728 | Single character patterns like 'a' appear frequently in this text.
5729 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5730 | It contains multiple lines with various patterns.
5731 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5732 | This helps test case-insensitive searching.
5733 | The quick brown fox jumps over the lazy dog.
5734 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5735 | Short patterns like ab should also be findable.
5736 | Single character patterns like 'a' appear frequently in this text.
5737 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5738 | It contains multiple lines with various patterns.
5739 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5740 | This helps test case-insensitive searching.
5741 | The quick brown fox jumps over the lazy dog.
5742 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5743 | Short patterns like ab should also be findable.
5744 | Single character patterns like 'a' appear frequently in this text.
5745 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5746 | It contains multiple lines with various patterns.
5747 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5748 | This helps test case-insensitive searching.
5749 | The quick brown fox jumps over the lazy dog.
5750 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5751 | Short patterns like ab should also be findable.
5752 | Single character patterns like 'a' appear frequently in this text.
5753 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5754 | It contains multiple lines with various patterns.
5755 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5756 | This helps test case-insensitive searching.
5757 | The quick brown fox jumps over the lazy dog.
5758 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5759 | Short patterns like ab should also be findable.
5760 | Single character patterns like 'a' appear frequently in this text.
5761 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5762 | It contains multiple lines with various patterns.
5763 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5764 | This helps test case-insensitive searching.
5765 | The quick brown fox jumps over the lazy dog.
5766 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5767 | Short patterns like ab should also be findable.
5768 | Single character patterns like 'a' appear frequently in this text.
5769 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5770 | It contains multiple lines with various patterns.
5771 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5772 | This helps test case-insensitive searching.
5773 | The quick brown fox jumps over the lazy dog.
5774 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5775 | Short patterns like ab should also be findable.
5776 | Single character patterns like 'a' appear frequently in this text.
5777 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5778 | It contains multiple lines with various patterns.
5779 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5780 | This helps test case-insensitive searching.
5781 | The quick brown fox jumps over the lazy dog.
5782 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5783 | Short patterns like ab should also be findable.
5784 | Single character patterns like 'a' appear frequently in this text.
5785 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5786 | It contains multiple lines with various patterns.
5787 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5788 | This helps test case-insensitive searching.
5789 | The quick brown fox jumps over the lazy dog.
5790 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5791 | Short patterns like ab should also be findable.
5792 | Single character patterns like 'a' appear frequently in this text.
5793 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5794 | It contains multiple lines with various patterns.
5795 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5796 | This helps test case-insensitive searching.
5797 | The quick brown fox jumps over the lazy dog.
5798 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5799 | Short patterns like ab should also be findable.
5800 | Single character patterns like 'a' appear frequently in this text.
5801 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5802 | It contains multiple lines with various patterns.
5803 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5804 | This helps test case-insensitive searching.
5805 | The quick brown fox jumps over the lazy dog.
5806 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5807 | Short patterns like ab should also be findable.
5808 | Single character patterns like 'a' appear frequently in this text.
5809 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5810 | It contains multiple lines with various patterns.
5811 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5812 | This helps test case-insensitive searching.
5813 | The quick brown fox jumps over the lazy dog.
5814 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5815 | Short patterns like ab should also be findable.
5816 | Single character patterns like 'a' appear frequently in this text.
5817 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5818 | It contains multiple lines with various patterns.
5819 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5820 | This helps test case-insensitive searching.
5821 | The quick brown fox jumps over the lazy dog.
5822 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5823 | Short patterns like ab should also be findable.
5824 | Single character patterns like 'a' appear frequently in this text.
5825 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5826 | It contains multiple lines with various patterns.
5827 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5828 | This helps test case-insensitive searching.
5829 | The quick brown fox jumps over the lazy dog.
5830 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5831 | Short patterns like ab should also be findable.
5832 | Single character patterns like 'a' appear frequently in this text.
5833 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5834 | It contains multiple lines with various patterns.
5835 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5836 | This helps test case-insensitive searching.
5837 | The quick brown fox jumps over the lazy dog.
5838 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5839 | Short patterns like ab should also be findable.
5840 | Single character patterns like 'a' appear frequently in this text.
5841 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5842 | It contains multiple lines with various patterns.
5843 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5844 | This helps test case-insensitive searching.
5845 | The quick brown fox jumps over the lazy dog.
5846 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5847 | Short patterns like ab should also be findable.
5848 | Single character patterns like 'a' appear frequently in this text.
5849 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5850 | It contains multiple lines with various patterns.
5851 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5852 | This helps test case-insensitive searching.
5853 | The quick brown fox jumps over the lazy dog.
5854 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5855 | Short patterns like ab should also be findable.
5856 | Single character patterns like 'a' appear frequently in this text.
5857 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5858 | It contains multiple lines with various patterns.
5859 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5860 | This helps test case-insensitive searching.
5861 | The quick brown fox jumps over the lazy dog.
5862 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5863 | Short patterns like ab should also be findable.
5864 | Single character patterns like 'a' appear frequently in this text.
5865 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5866 | It contains multiple lines with various patterns.
5867 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5868 | This helps test case-insensitive searching.
5869 | The quick brown fox jumps over the lazy dog.
5870 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5871 | Short patterns like ab should also be findable.
5872 | Single character patterns like 'a' appear frequently in this text.
5873 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5874 | It contains multiple lines with various patterns.
5875 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5876 | This helps test case-insensitive searching.
5877 | The quick brown fox jumps over the lazy dog.
5878 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5879 | Short patterns like ab should also be findable.
5880 | Single character patterns like 'a' appear frequently in this text.
5881 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5882 | It contains multiple lines with various patterns.
5883 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5884 | This helps test case-insensitive searching.
5885 | The quick brown fox jumps over the lazy dog.
5886 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5887 | Short patterns like ab should also be findable.
5888 | Single character patterns like 'a' appear frequently in this text.
5889 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5890 | It contains multiple lines with various patterns.
5891 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5892 | This helps test case-insensitive searching.
5893 | The quick brown fox jumps over the lazy dog.
5894 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5895 | Short patterns like ab should also be findable.
5896 | Single character patterns like 'a' appear frequently in this text.
5897 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5898 | It contains multiple lines with various patterns.
5899 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5900 | This helps test case-insensitive searching.
5901 | The quick brown fox jumps over the lazy dog.
5902 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5903 | Short patterns like ab should also be findable.
5904 | Single character patterns like 'a' appear frequently in this text.
5905 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5906 | It contains multiple lines with various patterns.
5907 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5908 | This helps test case-insensitive searching.
5909 | The quick brown fox jumps over the lazy dog.
5910 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5911 | Short patterns like ab should also be findable.
5912 | Single character patterns like 'a' appear frequently in this text.
5913 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5914 | It contains multiple lines with various patterns.
5915 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5916 | This helps test case-insensitive searching.
5917 | The quick brown fox jumps over the lazy dog.
5918 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5919 | Short patterns like ab should also be findable.
5920 | Single character patterns like 'a' appear frequently in this text.
5921 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5922 | It contains multiple lines with various patterns.
5923 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5924 | This helps test case-insensitive searching.
5925 | The quick brown fox jumps over the lazy dog.
5926 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5927 | Short patterns like ab should also be findable.
5928 | Single character patterns like 'a' appear frequently in this text.
5929 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5930 | It contains multiple lines with various patterns.
5931 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5932 | This helps test case-insensitive searching.
5933 | The quick brown fox jumps over the lazy dog.
5934 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5935 | Short patterns like ab should also be findable.
5936 | Single character patterns like 'a' appear frequently in this text.
5937 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5938 | It contains multiple lines with various patterns.
5939 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5940 | This helps test case-insensitive searching.
5941 | The quick brown fox jumps over the lazy dog.
5942 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5943 | Short patterns like ab should also be findable.
5944 | Single character patterns like 'a' appear frequently in this text.
5945 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5946 | It contains multiple lines with various patterns.
5947 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5948 | This helps test case-insensitive searching.
5949 | The quick brown fox jumps over the lazy dog.
5950 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5951 | Short patterns like ab should also be findable.
5952 | Single character patterns like 'a' appear frequently in this text.
5953 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5954 | It contains multiple lines with various patterns.
5955 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5956 | This helps test case-insensitive searching.
5957 | The quick brown fox jumps over the lazy dog.
5958 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5959 | Short patterns like ab should also be findable.
5960 | Single character patterns like 'a' appear frequently in this text.
5961 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5962 | It contains multiple lines with various patterns.
5963 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5964 | This helps test case-insensitive searching.
5965 | The quick brown fox jumps over the lazy dog.
5966 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5967 | Short patterns like ab should also be findable.
5968 | Single character patterns like 'a' appear frequently in this text.
5969 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5970 | It contains multiple lines with various patterns.
5971 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5972 | This helps test case-insensitive searching.
5973 | The quick brown fox jumps over the lazy dog.
5974 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5975 | Short patterns like ab should also be findable.
5976 | Single character patterns like 'a' appear frequently in this text.
5977 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5978 | It contains multiple lines with various patterns.
5979 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5980 | This helps test case-insensitive searching.
5981 | The quick brown fox jumps over the lazy dog.
5982 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5983 | Short patterns like ab should also be findable.
5984 | Single character patterns like 'a' appear frequently in this text.
5985 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5986 | It contains multiple lines with various patterns.
5987 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5988 | This helps test case-insensitive searching.
5989 | The quick brown fox jumps over the lazy dog.
5990 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5991 | Short patterns like ab should also be findable.
5992 | Single character patterns like 'a' appear frequently in this text.
5993 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
5994 | It contains multiple lines with various patterns.
5995 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
5996 | This helps test case-insensitive searching.
5997 | The quick brown fox jumps over the lazy dog.
5998 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
5999 | Short patterns like ab should also be findable.
6000 | Single character patterns like 'a' appear frequently in this text.
6001 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6002 | It contains multiple lines with various patterns.
6003 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6004 | This helps test case-insensitive searching.
6005 | The quick brown fox jumps over the lazy dog.
6006 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6007 | Short patterns like ab should also be findable.
6008 | Single character patterns like 'a' appear frequently in this text.
6009 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6010 | It contains multiple lines with various patterns.
6011 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6012 | This helps test case-insensitive searching.
6013 | The quick brown fox jumps over the lazy dog.
6014 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6015 | Short patterns like ab should also be findable.
6016 | Single character patterns like 'a' appear frequently in this text.
6017 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6018 | It contains multiple lines with various patterns.
6019 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6020 | This helps test case-insensitive searching.
6021 | The quick brown fox jumps over the lazy dog.
6022 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6023 | Short patterns like ab should also be findable.
6024 | Single character patterns like 'a' appear frequently in this text.
6025 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6026 | It contains multiple lines with various patterns.
6027 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6028 | This helps test case-insensitive searching.
6029 | The quick brown fox jumps over the lazy dog.
6030 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6031 | Short patterns like ab should also be findable.
6032 | Single character patterns like 'a' appear frequently in this text.
6033 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6034 | It contains multiple lines with various patterns.
6035 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6036 | This helps test case-insensitive searching.
6037 | The quick brown fox jumps over the lazy dog.
6038 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6039 | Short patterns like ab should also be findable.
6040 | Single character patterns like 'a' appear frequently in this text.
6041 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6042 | It contains multiple lines with various patterns.
6043 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6044 | This helps test case-insensitive searching.
6045 | The quick brown fox jumps over the lazy dog.
6046 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6047 | Short patterns like ab should also be findable.
6048 | Single character patterns like 'a' appear frequently in this text.
6049 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6050 | It contains multiple lines with various patterns.
6051 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6052 | This helps test case-insensitive searching.
6053 | The quick brown fox jumps over the lazy dog.
6054 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6055 | Short patterns like ab should also be findable.
6056 | Single character patterns like 'a' appear frequently in this text.
6057 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6058 | It contains multiple lines with various patterns.
6059 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6060 | This helps test case-insensitive searching.
6061 | The quick brown fox jumps over the lazy dog.
6062 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6063 | Short patterns like ab should also be findable.
6064 | Single character patterns like 'a' appear frequently in this text.
6065 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6066 | It contains multiple lines with various patterns.
6067 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6068 | This helps test case-insensitive searching.
6069 | The quick brown fox jumps over the lazy dog.
6070 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6071 | Short patterns like ab should also be findable.
6072 | Single character patterns like 'a' appear frequently in this text.
6073 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6074 | It contains multiple lines with various patterns.
6075 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6076 | This helps test case-insensitive searching.
6077 | The quick brown fox jumps over the lazy dog.
6078 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6079 | Short patterns like ab should also be findable.
6080 | Single character patterns like 'a' appear frequently in this text.
6081 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6082 | It contains multiple lines with various patterns.
6083 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6084 | This helps test case-insensitive searching.
6085 | The quick brown fox jumps over the lazy dog.
6086 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6087 | Short patterns like ab should also be findable.
6088 | Single character patterns like 'a' appear frequently in this text.
6089 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6090 | It contains multiple lines with various patterns.
6091 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6092 | This helps test case-insensitive searching.
6093 | The quick brown fox jumps over the lazy dog.
6094 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6095 | Short patterns like ab should also be findable.
6096 | Single character patterns like 'a' appear frequently in this text.
6097 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6098 | It contains multiple lines with various patterns.
6099 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6100 | This helps test case-insensitive searching.
6101 | The quick brown fox jumps over the lazy dog.
6102 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6103 | Short patterns like ab should also be findable.
6104 | Single character patterns like 'a' appear frequently in this text.
6105 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6106 | It contains multiple lines with various patterns.
6107 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6108 | This helps test case-insensitive searching.
6109 | The quick brown fox jumps over the lazy dog.
6110 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6111 | Short patterns like ab should also be findable.
6112 | Single character patterns like 'a' appear frequently in this text.
6113 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6114 | It contains multiple lines with various patterns.
6115 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6116 | This helps test case-insensitive searching.
6117 | The quick brown fox jumps over the lazy dog.
6118 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6119 | Short patterns like ab should also be findable.
6120 | Single character patterns like 'a' appear frequently in this text.
6121 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6122 | It contains multiple lines with various patterns.
6123 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6124 | This helps test case-insensitive searching.
6125 | The quick brown fox jumps over the lazy dog.
6126 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6127 | Short patterns like ab should also be findable.
6128 | Single character patterns like 'a' appear frequently in this text.
6129 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6130 | It contains multiple lines with various patterns.
6131 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6132 | This helps test case-insensitive searching.
6133 | The quick brown fox jumps over the lazy dog.
6134 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6135 | Short patterns like ab should also be findable.
6136 | Single character patterns like 'a' appear frequently in this text.
6137 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6138 | It contains multiple lines with various patterns.
6139 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6140 | This helps test case-insensitive searching.
6141 | The quick brown fox jumps over the lazy dog.
6142 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6143 | Short patterns like ab should also be findable.
6144 | Single character patterns like 'a' appear frequently in this text.
6145 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6146 | It contains multiple lines with various patterns.
6147 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6148 | This helps test case-insensitive searching.
6149 | The quick brown fox jumps over the lazy dog.
6150 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6151 | Short patterns like ab should also be findable.
6152 | Single character patterns like 'a' appear frequently in this text.
6153 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6154 | It contains multiple lines with various patterns.
6155 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6156 | This helps test case-insensitive searching.
6157 | The quick brown fox jumps over the lazy dog.
6158 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6159 | Short patterns like ab should also be findable.
6160 | Single character patterns like 'a' appear frequently in this text.
6161 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6162 | It contains multiple lines with various patterns.
6163 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6164 | This helps test case-insensitive searching.
6165 | The quick brown fox jumps over the lazy dog.
6166 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6167 | Short patterns like ab should also be findable.
6168 | Single character patterns like 'a' appear frequently in this text.
6169 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6170 | It contains multiple lines with various patterns.
6171 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6172 | This helps test case-insensitive searching.
6173 | The quick brown fox jumps over the lazy dog.
6174 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6175 | Short patterns like ab should also be findable.
6176 | Single character patterns like 'a' appear frequently in this text.
6177 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6178 | It contains multiple lines with various patterns.
6179 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6180 | This helps test case-insensitive searching.
6181 | The quick brown fox jumps over the lazy dog.
6182 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6183 | Short patterns like ab should also be findable.
6184 | Single character patterns like 'a' appear frequently in this text.
6185 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6186 | It contains multiple lines with various patterns.
6187 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6188 | This helps test case-insensitive searching.
6189 | The quick brown fox jumps over the lazy dog.
6190 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6191 | Short patterns like ab should also be findable.
6192 | Single character patterns like 'a' appear frequently in this text.
6193 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6194 | It contains multiple lines with various patterns.
6195 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6196 | This helps test case-insensitive searching.
6197 | The quick brown fox jumps over the lazy dog.
6198 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6199 | Short patterns like ab should also be findable.
6200 | Single character patterns like 'a' appear frequently in this text.
6201 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6202 | It contains multiple lines with various patterns.
6203 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6204 | This helps test case-insensitive searching.
6205 | The quick brown fox jumps over the lazy dog.
6206 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6207 | Short patterns like ab should also be findable.
6208 | Single character patterns like 'a' appear frequently in this text.
6209 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6210 | It contains multiple lines with various patterns.
6211 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6212 | This helps test case-insensitive searching.
6213 | The quick brown fox jumps over the lazy dog.
6214 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6215 | Short patterns like ab should also be findable.
6216 | Single character patterns like 'a' appear frequently in this text.
6217 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6218 | It contains multiple lines with various patterns.
6219 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6220 | This helps test case-insensitive searching.
6221 | The quick brown fox jumps over the lazy dog.
6222 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6223 | Short patterns like ab should also be findable.
6224 | Single character patterns like 'a' appear frequently in this text.
6225 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6226 | It contains multiple lines with various patterns.
6227 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6228 | This helps test case-insensitive searching.
6229 | The quick brown fox jumps over the lazy dog.
6230 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6231 | Short patterns like ab should also be findable.
6232 | Single character patterns like 'a' appear frequently in this text.
6233 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6234 | It contains multiple lines with various patterns.
6235 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6236 | This helps test case-insensitive searching.
6237 | The quick brown fox jumps over the lazy dog.
6238 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6239 | Short patterns like ab should also be findable.
6240 | Single character patterns like 'a' appear frequently in this text.
6241 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6242 | It contains multiple lines with various patterns.
6243 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6244 | This helps test case-insensitive searching.
6245 | The quick brown fox jumps over the lazy dog.
6246 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6247 | Short patterns like ab should also be findable.
6248 | Single character patterns like 'a' appear frequently in this text.
6249 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6250 | It contains multiple lines with various patterns.
6251 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6252 | This helps test case-insensitive searching.
6253 | The quick brown fox jumps over the lazy dog.
6254 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6255 | Short patterns like ab should also be findable.
6256 | Single character patterns like 'a' appear frequently in this text.
6257 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6258 | It contains multiple lines with various patterns.
6259 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6260 | This helps test case-insensitive searching.
6261 | The quick brown fox jumps over the lazy dog.
6262 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6263 | Short patterns like ab should also be findable.
6264 | Single character patterns like 'a' appear frequently in this text.
6265 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6266 | It contains multiple lines with various patterns.
6267 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6268 | This helps test case-insensitive searching.
6269 | The quick brown fox jumps over the lazy dog.
6270 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6271 | Short patterns like ab should also be findable.
6272 | Single character patterns like 'a' appear frequently in this text.
6273 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6274 | It contains multiple lines with various patterns.
6275 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6276 | This helps test case-insensitive searching.
6277 | The quick brown fox jumps over the lazy dog.
6278 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6279 | Short patterns like ab should also be findable.
6280 | Single character patterns like 'a' appear frequently in this text.
6281 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6282 | It contains multiple lines with various patterns.
6283 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6284 | This helps test case-insensitive searching.
6285 | The quick brown fox jumps over the lazy dog.
6286 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6287 | Short patterns like ab should also be findable.
6288 | Single character patterns like 'a' appear frequently in this text.
6289 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6290 | It contains multiple lines with various patterns.
6291 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6292 | This helps test case-insensitive searching.
6293 | The quick brown fox jumps over the lazy dog.
6294 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6295 | Short patterns like ab should also be findable.
6296 | Single character patterns like 'a' appear frequently in this text.
6297 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6298 | It contains multiple lines with various patterns.
6299 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6300 | This helps test case-insensitive searching.
6301 | The quick brown fox jumps over the lazy dog.
6302 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6303 | Short patterns like ab should also be findable.
6304 | Single character patterns like 'a' appear frequently in this text.
6305 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6306 | It contains multiple lines with various patterns.
6307 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6308 | This helps test case-insensitive searching.
6309 | The quick brown fox jumps over the lazy dog.
6310 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6311 | Short patterns like ab should also be findable.
6312 | Single character patterns like 'a' appear frequently in this text.
6313 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6314 | It contains multiple lines with various patterns.
6315 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6316 | This helps test case-insensitive searching.
6317 | The quick brown fox jumps over the lazy dog.
6318 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6319 | Short patterns like ab should also be findable.
6320 | Single character patterns like 'a' appear frequently in this text.
6321 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6322 | It contains multiple lines with various patterns.
6323 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6324 | This helps test case-insensitive searching.
6325 | The quick brown fox jumps over the lazy dog.
6326 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6327 | Short patterns like ab should also be findable.
6328 | Single character patterns like 'a' appear frequently in this text.
6329 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6330 | It contains multiple lines with various patterns.
6331 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6332 | This helps test case-insensitive searching.
6333 | The quick brown fox jumps over the lazy dog.
6334 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6335 | Short patterns like ab should also be findable.
6336 | Single character patterns like 'a' appear frequently in this text.
6337 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6338 | It contains multiple lines with various patterns.
6339 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6340 | This helps test case-insensitive searching.
6341 | The quick brown fox jumps over the lazy dog.
6342 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6343 | Short patterns like ab should also be findable.
6344 | Single character patterns like 'a' appear frequently in this text.
6345 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6346 | It contains multiple lines with various patterns.
6347 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6348 | This helps test case-insensitive searching.
6349 | The quick brown fox jumps over the lazy dog.
6350 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6351 | Short patterns like ab should also be findable.
6352 | Single character patterns like 'a' appear frequently in this text.
6353 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6354 | It contains multiple lines with various patterns.
6355 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6356 | This helps test case-insensitive searching.
6357 | The quick brown fox jumps over the lazy dog.
6358 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6359 | Short patterns like ab should also be findable.
6360 | Single character patterns like 'a' appear frequently in this text.
6361 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6362 | It contains multiple lines with various patterns.
6363 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6364 | This helps test case-insensitive searching.
6365 | The quick brown fox jumps over the lazy dog.
6366 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6367 | Short patterns like ab should also be findable.
6368 | Single character patterns like 'a' appear frequently in this text.
6369 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6370 | It contains multiple lines with various patterns.
6371 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6372 | This helps test case-insensitive searching.
6373 | The quick brown fox jumps over the lazy dog.
6374 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6375 | Short patterns like ab should also be findable.
6376 | Single character patterns like 'a' appear frequently in this text.
6377 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6378 | It contains multiple lines with various patterns.
6379 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6380 | This helps test case-insensitive searching.
6381 | The quick brown fox jumps over the lazy dog.
6382 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6383 | Short patterns like ab should also be findable.
6384 | Single character patterns like 'a' appear frequently in this text.
6385 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6386 | It contains multiple lines with various patterns.
6387 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6388 | This helps test case-insensitive searching.
6389 | The quick brown fox jumps over the lazy dog.
6390 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6391 | Short patterns like ab should also be findable.
6392 | Single character patterns like 'a' appear frequently in this text.
6393 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6394 | It contains multiple lines with various patterns.
6395 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6396 | This helps test case-insensitive searching.
6397 | The quick brown fox jumps over the lazy dog.
6398 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6399 | Short patterns like ab should also be findable.
6400 | Single character patterns like 'a' appear frequently in this text.
6401 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6402 | It contains multiple lines with various patterns.
6403 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6404 | This helps test case-insensitive searching.
6405 | The quick brown fox jumps over the lazy dog.
6406 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6407 | Short patterns like ab should also be findable.
6408 | Single character patterns like 'a' appear frequently in this text.
6409 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6410 | It contains multiple lines with various patterns.
6411 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6412 | This helps test case-insensitive searching.
6413 | The quick brown fox jumps over the lazy dog.
6414 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6415 | Short patterns like ab should also be findable.
6416 | Single character patterns like 'a' appear frequently in this text.
6417 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6418 | It contains multiple lines with various patterns.
6419 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6420 | This helps test case-insensitive searching.
6421 | The quick brown fox jumps over the lazy dog.
6422 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6423 | Short patterns like ab should also be findable.
6424 | Single character patterns like 'a' appear frequently in this text.
6425 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6426 | It contains multiple lines with various patterns.
6427 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6428 | This helps test case-insensitive searching.
6429 | The quick brown fox jumps over the lazy dog.
6430 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6431 | Short patterns like ab should also be findable.
6432 | Single character patterns like 'a' appear frequently in this text.
6433 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6434 | It contains multiple lines with various patterns.
6435 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6436 | This helps test case-insensitive searching.
6437 | The quick brown fox jumps over the lazy dog.
6438 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6439 | Short patterns like ab should also be findable.
6440 | Single character patterns like 'a' appear frequently in this text.
6441 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6442 | It contains multiple lines with various patterns.
6443 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6444 | This helps test case-insensitive searching.
6445 | The quick brown fox jumps over the lazy dog.
6446 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6447 | Short patterns like ab should also be findable.
6448 | Single character patterns like 'a' appear frequently in this text.
6449 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6450 | It contains multiple lines with various patterns.
6451 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6452 | This helps test case-insensitive searching.
6453 | The quick brown fox jumps over the lazy dog.
6454 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6455 | Short patterns like ab should also be findable.
6456 | Single character patterns like 'a' appear frequently in this text.
6457 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6458 | It contains multiple lines with various patterns.
6459 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6460 | This helps test case-insensitive searching.
6461 | The quick brown fox jumps over the lazy dog.
6462 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6463 | Short patterns like ab should also be findable.
6464 | Single character patterns like 'a' appear frequently in this text.
6465 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6466 | It contains multiple lines with various patterns.
6467 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6468 | This helps test case-insensitive searching.
6469 | The quick brown fox jumps over the lazy dog.
6470 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6471 | Short patterns like ab should also be findable.
6472 | Single character patterns like 'a' appear frequently in this text.
6473 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6474 | It contains multiple lines with various patterns.
6475 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6476 | This helps test case-insensitive searching.
6477 | The quick brown fox jumps over the lazy dog.
6478 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6479 | Short patterns like ab should also be findable.
6480 | Single character patterns like 'a' appear frequently in this text.
6481 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6482 | It contains multiple lines with various patterns.
6483 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6484 | This helps test case-insensitive searching.
6485 | The quick brown fox jumps over the lazy dog.
6486 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6487 | Short patterns like ab should also be findable.
6488 | Single character patterns like 'a' appear frequently in this text.
6489 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6490 | It contains multiple lines with various patterns.
6491 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6492 | This helps test case-insensitive searching.
6493 | The quick brown fox jumps over the lazy dog.
6494 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6495 | Short patterns like ab should also be findable.
6496 | Single character patterns like 'a' appear frequently in this text.
6497 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6498 | It contains multiple lines with various patterns.
6499 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6500 | This helps test case-insensitive searching.
6501 | The quick brown fox jumps over the lazy dog.
6502 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6503 | Short patterns like ab should also be findable.
6504 | Single character patterns like 'a' appear frequently in this text.
6505 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6506 | It contains multiple lines with various patterns.
6507 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6508 | This helps test case-insensitive searching.
6509 | The quick brown fox jumps over the lazy dog.
6510 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6511 | Short patterns like ab should also be findable.
6512 | Single character patterns like 'a' appear frequently in this text.
6513 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6514 | It contains multiple lines with various patterns.
6515 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6516 | This helps test case-insensitive searching.
6517 | The quick brown fox jumps over the lazy dog.
6518 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6519 | Short patterns like ab should also be findable.
6520 | Single character patterns like 'a' appear frequently in this text.
6521 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6522 | It contains multiple lines with various patterns.
6523 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6524 | This helps test case-insensitive searching.
6525 | The quick brown fox jumps over the lazy dog.
6526 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6527 | Short patterns like ab should also be findable.
6528 | Single character patterns like 'a' appear frequently in this text.
6529 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6530 | It contains multiple lines with various patterns.
6531 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6532 | This helps test case-insensitive searching.
6533 | The quick brown fox jumps over the lazy dog.
6534 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6535 | Short patterns like ab should also be findable.
6536 | Single character patterns like 'a' appear frequently in this text.
6537 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6538 | It contains multiple lines with various patterns.
6539 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6540 | This helps test case-insensitive searching.
6541 | The quick brown fox jumps over the lazy dog.
6542 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6543 | Short patterns like ab should also be findable.
6544 | Single character patterns like 'a' appear frequently in this text.
6545 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6546 | It contains multiple lines with various patterns.
6547 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6548 | This helps test case-insensitive searching.
6549 | The quick brown fox jumps over the lazy dog.
6550 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6551 | Short patterns like ab should also be findable.
6552 | Single character patterns like 'a' appear frequently in this text.
6553 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6554 | It contains multiple lines with various patterns.
6555 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6556 | This helps test case-insensitive searching.
6557 | The quick brown fox jumps over the lazy dog.
6558 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6559 | Short patterns like ab should also be findable.
6560 | Single character patterns like 'a' appear frequently in this text.
6561 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6562 | It contains multiple lines with various patterns.
6563 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6564 | This helps test case-insensitive searching.
6565 | The quick brown fox jumps over the lazy dog.
6566 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6567 | Short patterns like ab should also be findable.
6568 | Single character patterns like 'a' appear frequently in this text.
6569 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6570 | It contains multiple lines with various patterns.
6571 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6572 | This helps test case-insensitive searching.
6573 | The quick brown fox jumps over the lazy dog.
6574 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6575 | Short patterns like ab should also be findable.
6576 | Single character patterns like 'a' appear frequently in this text.
6577 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6578 | It contains multiple lines with various patterns.
6579 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6580 | This helps test case-insensitive searching.
6581 | The quick brown fox jumps over the lazy dog.
6582 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6583 | Short patterns like ab should also be findable.
6584 | Single character patterns like 'a' appear frequently in this text.
6585 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6586 | It contains multiple lines with various patterns.
6587 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6588 | This helps test case-insensitive searching.
6589 | The quick brown fox jumps over the lazy dog.
6590 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6591 | Short patterns like ab should also be findable.
6592 | Single character patterns like 'a' appear frequently in this text.
6593 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6594 | It contains multiple lines with various patterns.
6595 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6596 | This helps test case-insensitive searching.
6597 | The quick brown fox jumps over the lazy dog.
6598 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6599 | Short patterns like ab should also be findable.
6600 | Single character patterns like 'a' appear frequently in this text.
6601 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6602 | It contains multiple lines with various patterns.
6603 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6604 | This helps test case-insensitive searching.
6605 | The quick brown fox jumps over the lazy dog.
6606 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6607 | Short patterns like ab should also be findable.
6608 | Single character patterns like 'a' appear frequently in this text.
6609 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6610 | It contains multiple lines with various patterns.
6611 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6612 | This helps test case-insensitive searching.
6613 | The quick brown fox jumps over the lazy dog.
6614 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6615 | Short patterns like ab should also be findable.
6616 | Single character patterns like 'a' appear frequently in this text.
6617 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6618 | It contains multiple lines with various patterns.
6619 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6620 | This helps test case-insensitive searching.
6621 | The quick brown fox jumps over the lazy dog.
6622 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6623 | Short patterns like ab should also be findable.
6624 | Single character patterns like 'a' appear frequently in this text.
6625 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6626 | It contains multiple lines with various patterns.
6627 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6628 | This helps test case-insensitive searching.
6629 | The quick brown fox jumps over the lazy dog.
6630 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6631 | Short patterns like ab should also be findable.
6632 | Single character patterns like 'a' appear frequently in this text.
6633 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6634 | It contains multiple lines with various patterns.
6635 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6636 | This helps test case-insensitive searching.
6637 | The quick brown fox jumps over the lazy dog.
6638 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6639 | Short patterns like ab should also be findable.
6640 | Single character patterns like 'a' appear frequently in this text.
6641 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6642 | It contains multiple lines with various patterns.
6643 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6644 | This helps test case-insensitive searching.
6645 | The quick brown fox jumps over the lazy dog.
6646 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6647 | Short patterns like ab should also be findable.
6648 | Single character patterns like 'a' appear frequently in this text.
6649 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6650 | It contains multiple lines with various patterns.
6651 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6652 | This helps test case-insensitive searching.
6653 | The quick brown fox jumps over the lazy dog.
6654 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6655 | Short patterns like ab should also be findable.
6656 | Single character patterns like 'a' appear frequently in this text.
6657 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6658 | It contains multiple lines with various patterns.
6659 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6660 | This helps test case-insensitive searching.
6661 | The quick brown fox jumps over the lazy dog.
6662 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6663 | Short patterns like ab should also be findable.
6664 | Single character patterns like 'a' appear frequently in this text.
6665 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6666 | It contains multiple lines with various patterns.
6667 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6668 | This helps test case-insensitive searching.
6669 | The quick brown fox jumps over the lazy dog.
6670 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6671 | Short patterns like ab should also be findable.
6672 | Single character patterns like 'a' appear frequently in this text.
6673 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6674 | It contains multiple lines with various patterns.
6675 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6676 | This helps test case-insensitive searching.
6677 | The quick brown fox jumps over the lazy dog.
6678 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6679 | Short patterns like ab should also be findable.
6680 | Single character patterns like 'a' appear frequently in this text.
6681 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6682 | It contains multiple lines with various patterns.
6683 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6684 | This helps test case-insensitive searching.
6685 | The quick brown fox jumps over the lazy dog.
6686 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6687 | Short patterns like ab should also be findable.
6688 | Single character patterns like 'a' appear frequently in this text.
6689 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6690 | It contains multiple lines with various patterns.
6691 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6692 | This helps test case-insensitive searching.
6693 | The quick brown fox jumps over the lazy dog.
6694 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6695 | Short patterns like ab should also be findable.
6696 | Single character patterns like 'a' appear frequently in this text.
6697 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6698 | It contains multiple lines with various patterns.
6699 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6700 | This helps test case-insensitive searching.
6701 | The quick brown fox jumps over the lazy dog.
6702 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6703 | Short patterns like ab should also be findable.
6704 | Single character patterns like 'a' appear frequently in this text.
6705 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6706 | It contains multiple lines with various patterns.
6707 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6708 | This helps test case-insensitive searching.
6709 | The quick brown fox jumps over the lazy dog.
6710 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6711 | Short patterns like ab should also be findable.
6712 | Single character patterns like 'a' appear frequently in this text.
6713 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6714 | It contains multiple lines with various patterns.
6715 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6716 | This helps test case-insensitive searching.
6717 | The quick brown fox jumps over the lazy dog.
6718 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6719 | Short patterns like ab should also be findable.
6720 | Single character patterns like 'a' appear frequently in this text.
6721 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6722 | It contains multiple lines with various patterns.
6723 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6724 | This helps test case-insensitive searching.
6725 | The quick brown fox jumps over the lazy dog.
6726 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6727 | Short patterns like ab should also be findable.
6728 | Single character patterns like 'a' appear frequently in this text.
6729 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6730 | It contains multiple lines with various patterns.
6731 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6732 | This helps test case-insensitive searching.
6733 | The quick brown fox jumps over the lazy dog.
6734 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6735 | Short patterns like ab should also be findable.
6736 | Single character patterns like 'a' appear frequently in this text.
6737 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6738 | It contains multiple lines with various patterns.
6739 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6740 | This helps test case-insensitive searching.
6741 | The quick brown fox jumps over the lazy dog.
6742 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6743 | Short patterns like ab should also be findable.
6744 | Single character patterns like 'a' appear frequently in this text.
6745 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6746 | It contains multiple lines with various patterns.
6747 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6748 | This helps test case-insensitive searching.
6749 | The quick brown fox jumps over the lazy dog.
6750 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6751 | Short patterns like ab should also be findable.
6752 | Single character patterns like 'a' appear frequently in this text.
6753 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6754 | It contains multiple lines with various patterns.
6755 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6756 | This helps test case-insensitive searching.
6757 | The quick brown fox jumps over the lazy dog.
6758 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6759 | Short patterns like ab should also be findable.
6760 | Single character patterns like 'a' appear frequently in this text.
6761 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6762 | It contains multiple lines with various patterns.
6763 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6764 | This helps test case-insensitive searching.
6765 | The quick brown fox jumps over the lazy dog.
6766 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6767 | Short patterns like ab should also be findable.
6768 | Single character patterns like 'a' appear frequently in this text.
6769 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6770 | It contains multiple lines with various patterns.
6771 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6772 | This helps test case-insensitive searching.
6773 | The quick brown fox jumps over the lazy dog.
6774 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6775 | Short patterns like ab should also be findable.
6776 | Single character patterns like 'a' appear frequently in this text.
6777 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6778 | It contains multiple lines with various patterns.
6779 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6780 | This helps test case-insensitive searching.
6781 | The quick brown fox jumps over the lazy dog.
6782 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6783 | Short patterns like ab should also be findable.
6784 | Single character patterns like 'a' appear frequently in this text.
6785 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6786 | It contains multiple lines with various patterns.
6787 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6788 | This helps test case-insensitive searching.
6789 | The quick brown fox jumps over the lazy dog.
6790 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6791 | Short patterns like ab should also be findable.
6792 | Single character patterns like 'a' appear frequently in this text.
6793 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6794 | It contains multiple lines with various patterns.
6795 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6796 | This helps test case-insensitive searching.
6797 | The quick brown fox jumps over the lazy dog.
6798 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6799 | Short patterns like ab should also be findable.
6800 | Single character patterns like 'a' appear frequently in this text.
6801 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6802 | It contains multiple lines with various patterns.
6803 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6804 | This helps test case-insensitive searching.
6805 | The quick brown fox jumps over the lazy dog.
6806 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6807 | Short patterns like ab should also be findable.
6808 | Single character patterns like 'a' appear frequently in this text.
6809 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6810 | It contains multiple lines with various patterns.
6811 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6812 | This helps test case-insensitive searching.
6813 | The quick brown fox jumps over the lazy dog.
6814 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6815 | Short patterns like ab should also be findable.
6816 | Single character patterns like 'a' appear frequently in this text.
6817 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6818 | It contains multiple lines with various patterns.
6819 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6820 | This helps test case-insensitive searching.
6821 | The quick brown fox jumps over the lazy dog.
6822 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6823 | Short patterns like ab should also be findable.
6824 | Single character patterns like 'a' appear frequently in this text.
6825 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6826 | It contains multiple lines with various patterns.
6827 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6828 | This helps test case-insensitive searching.
6829 | The quick brown fox jumps over the lazy dog.
6830 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6831 | Short patterns like ab should also be findable.
6832 | Single character patterns like 'a' appear frequently in this text.
6833 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6834 | It contains multiple lines with various patterns.
6835 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6836 | This helps test case-insensitive searching.
6837 | The quick brown fox jumps over the lazy dog.
6838 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6839 | Short patterns like ab should also be findable.
6840 | Single character patterns like 'a' appear frequently in this text.
6841 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6842 | It contains multiple lines with various patterns.
6843 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6844 | This helps test case-insensitive searching.
6845 | The quick brown fox jumps over the lazy dog.
6846 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6847 | Short patterns like ab should also be findable.
6848 | Single character patterns like 'a' appear frequently in this text.
6849 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6850 | It contains multiple lines with various patterns.
6851 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6852 | This helps test case-insensitive searching.
6853 | The quick brown fox jumps over the lazy dog.
6854 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6855 | Short patterns like ab should also be findable.
6856 | Single character patterns like 'a' appear frequently in this text.
6857 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6858 | It contains multiple lines with various patterns.
6859 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6860 | This helps test case-insensitive searching.
6861 | The quick brown fox jumps over the lazy dog.
6862 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6863 | Short patterns like ab should also be findable.
6864 | Single character patterns like 'a' appear frequently in this text.
6865 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6866 | It contains multiple lines with various patterns.
6867 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6868 | This helps test case-insensitive searching.
6869 | The quick brown fox jumps over the lazy dog.
6870 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6871 | Short patterns like ab should also be findable.
6872 | Single character patterns like 'a' appear frequently in this text.
6873 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6874 | It contains multiple lines with various patterns.
6875 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6876 | This helps test case-insensitive searching.
6877 | The quick brown fox jumps over the lazy dog.
6878 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6879 | Short patterns like ab should also be findable.
6880 | Single character patterns like 'a' appear frequently in this text.
6881 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6882 | It contains multiple lines with various patterns.
6883 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6884 | This helps test case-insensitive searching.
6885 | The quick brown fox jumps over the lazy dog.
6886 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6887 | Short patterns like ab should also be findable.
6888 | Single character patterns like 'a' appear frequently in this text.
6889 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6890 | It contains multiple lines with various patterns.
6891 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6892 | This helps test case-insensitive searching.
6893 | The quick brown fox jumps over the lazy dog.
6894 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6895 | Short patterns like ab should also be findable.
6896 | Single character patterns like 'a' appear frequently in this text.
6897 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6898 | It contains multiple lines with various patterns.
6899 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6900 | This helps test case-insensitive searching.
6901 | The quick brown fox jumps over the lazy dog.
6902 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6903 | Short patterns like ab should also be findable.
6904 | Single character patterns like 'a' appear frequently in this text.
6905 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6906 | It contains multiple lines with various patterns.
6907 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6908 | This helps test case-insensitive searching.
6909 | The quick brown fox jumps over the lazy dog.
6910 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6911 | Short patterns like ab should also be findable.
6912 | Single character patterns like 'a' appear frequently in this text.
6913 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6914 | It contains multiple lines with various patterns.
6915 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6916 | This helps test case-insensitive searching.
6917 | The quick brown fox jumps over the lazy dog.
6918 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6919 | Short patterns like ab should also be findable.
6920 | Single character patterns like 'a' appear frequently in this text.
6921 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6922 | It contains multiple lines with various patterns.
6923 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6924 | This helps test case-insensitive searching.
6925 | The quick brown fox jumps over the lazy dog.
6926 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6927 | Short patterns like ab should also be findable.
6928 | Single character patterns like 'a' appear frequently in this text.
6929 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6930 | It contains multiple lines with various patterns.
6931 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6932 | This helps test case-insensitive searching.
6933 | The quick brown fox jumps over the lazy dog.
6934 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6935 | Short patterns like ab should also be findable.
6936 | Single character patterns like 'a' appear frequently in this text.
6937 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6938 | It contains multiple lines with various patterns.
6939 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6940 | This helps test case-insensitive searching.
6941 | The quick brown fox jumps over the lazy dog.
6942 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6943 | Short patterns like ab should also be findable.
6944 | Single character patterns like 'a' appear frequently in this text.
6945 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6946 | It contains multiple lines with various patterns.
6947 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6948 | This helps test case-insensitive searching.
6949 | The quick brown fox jumps over the lazy dog.
6950 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6951 | Short patterns like ab should also be findable.
6952 | Single character patterns like 'a' appear frequently in this text.
6953 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6954 | It contains multiple lines with various patterns.
6955 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6956 | This helps test case-insensitive searching.
6957 | The quick brown fox jumps over the lazy dog.
6958 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6959 | Short patterns like ab should also be findable.
6960 | Single character patterns like 'a' appear frequently in this text.
6961 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6962 | It contains multiple lines with various patterns.
6963 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6964 | This helps test case-insensitive searching.
6965 | The quick brown fox jumps over the lazy dog.
6966 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6967 | Short patterns like ab should also be findable.
6968 | Single character patterns like 'a' appear frequently in this text.
6969 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6970 | It contains multiple lines with various patterns.
6971 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6972 | This helps test case-insensitive searching.
6973 | The quick brown fox jumps over the lazy dog.
6974 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6975 | Short patterns like ab should also be findable.
6976 | Single character patterns like 'a' appear frequently in this text.
6977 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6978 | It contains multiple lines with various patterns.
6979 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6980 | This helps test case-insensitive searching.
6981 | The quick brown fox jumps over the lazy dog.
6982 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6983 | Short patterns like ab should also be findable.
6984 | Single character patterns like 'a' appear frequently in this text.
6985 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6986 | It contains multiple lines with various patterns.
6987 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6988 | This helps test case-insensitive searching.
6989 | The quick brown fox jumps over the lazy dog.
6990 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6991 | Short patterns like ab should also be findable.
6992 | Single character patterns like 'a' appear frequently in this text.
6993 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
6994 | It contains multiple lines with various patterns.
6995 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
6996 | This helps test case-insensitive searching.
6997 | The quick brown fox jumps over the lazy dog.
6998 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
6999 | Short patterns like ab should also be findable.
7000 | Single character patterns like 'a' appear frequently in this text.
7001 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7002 | It contains multiple lines with various patterns.
7003 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7004 | This helps test case-insensitive searching.
7005 | The quick brown fox jumps over the lazy dog.
7006 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7007 | Short patterns like ab should also be findable.
7008 | Single character patterns like 'a' appear frequently in this text.
7009 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7010 | It contains multiple lines with various patterns.
7011 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7012 | This helps test case-insensitive searching.
7013 | The quick brown fox jumps over the lazy dog.
7014 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7015 | Short patterns like ab should also be findable.
7016 | Single character patterns like 'a' appear frequently in this text.
7017 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7018 | It contains multiple lines with various patterns.
7019 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7020 | This helps test case-insensitive searching.
7021 | The quick brown fox jumps over the lazy dog.
7022 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7023 | Short patterns like ab should also be findable.
7024 | Single character patterns like 'a' appear frequently in this text.
7025 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7026 | It contains multiple lines with various patterns.
7027 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7028 | This helps test case-insensitive searching.
7029 | The quick brown fox jumps over the lazy dog.
7030 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7031 | Short patterns like ab should also be findable.
7032 | Single character patterns like 'a' appear frequently in this text.
7033 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7034 | It contains multiple lines with various patterns.
7035 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7036 | This helps test case-insensitive searching.
7037 | The quick brown fox jumps over the lazy dog.
7038 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7039 | Short patterns like ab should also be findable.
7040 | Single character patterns like 'a' appear frequently in this text.
7041 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7042 | It contains multiple lines with various patterns.
7043 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7044 | This helps test case-insensitive searching.
7045 | The quick brown fox jumps over the lazy dog.
7046 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7047 | Short patterns like ab should also be findable.
7048 | Single character patterns like 'a' appear frequently in this text.
7049 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7050 | It contains multiple lines with various patterns.
7051 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7052 | This helps test case-insensitive searching.
7053 | The quick brown fox jumps over the lazy dog.
7054 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7055 | Short patterns like ab should also be findable.
7056 | Single character patterns like 'a' appear frequently in this text.
7057 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7058 | It contains multiple lines with various patterns.
7059 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7060 | This helps test case-insensitive searching.
7061 | The quick brown fox jumps over the lazy dog.
7062 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7063 | Short patterns like ab should also be findable.
7064 | Single character patterns like 'a' appear frequently in this text.
7065 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7066 | It contains multiple lines with various patterns.
7067 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7068 | This helps test case-insensitive searching.
7069 | The quick brown fox jumps over the lazy dog.
7070 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7071 | Short patterns like ab should also be findable.
7072 | Single character patterns like 'a' appear frequently in this text.
7073 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7074 | It contains multiple lines with various patterns.
7075 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7076 | This helps test case-insensitive searching.
7077 | The quick brown fox jumps over the lazy dog.
7078 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7079 | Short patterns like ab should also be findable.
7080 | Single character patterns like 'a' appear frequently in this text.
7081 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7082 | It contains multiple lines with various patterns.
7083 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7084 | This helps test case-insensitive searching.
7085 | The quick brown fox jumps over the lazy dog.
7086 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7087 | Short patterns like ab should also be findable.
7088 | Single character patterns like 'a' appear frequently in this text.
7089 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7090 | It contains multiple lines with various patterns.
7091 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7092 | This helps test case-insensitive searching.
7093 | The quick brown fox jumps over the lazy dog.
7094 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7095 | Short patterns like ab should also be findable.
7096 | Single character patterns like 'a' appear frequently in this text.
7097 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7098 | It contains multiple lines with various patterns.
7099 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7100 | This helps test case-insensitive searching.
7101 | The quick brown fox jumps over the lazy dog.
7102 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7103 | Short patterns like ab should also be findable.
7104 | Single character patterns like 'a' appear frequently in this text.
7105 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7106 | It contains multiple lines with various patterns.
7107 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7108 | This helps test case-insensitive searching.
7109 | The quick brown fox jumps over the lazy dog.
7110 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7111 | Short patterns like ab should also be findable.
7112 | Single character patterns like 'a' appear frequently in this text.
7113 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7114 | It contains multiple lines with various patterns.
7115 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7116 | This helps test case-insensitive searching.
7117 | The quick brown fox jumps over the lazy dog.
7118 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7119 | Short patterns like ab should also be findable.
7120 | Single character patterns like 'a' appear frequently in this text.
7121 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7122 | It contains multiple lines with various patterns.
7123 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7124 | This helps test case-insensitive searching.
7125 | The quick brown fox jumps over the lazy dog.
7126 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7127 | Short patterns like ab should also be findable.
7128 | Single character patterns like 'a' appear frequently in this text.
7129 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7130 | It contains multiple lines with various patterns.
7131 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7132 | This helps test case-insensitive searching.
7133 | The quick brown fox jumps over the lazy dog.
7134 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7135 | Short patterns like ab should also be findable.
7136 | Single character patterns like 'a' appear frequently in this text.
7137 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7138 | It contains multiple lines with various patterns.
7139 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7140 | This helps test case-insensitive searching.
7141 | The quick brown fox jumps over the lazy dog.
7142 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7143 | Short patterns like ab should also be findable.
7144 | Single character patterns like 'a' appear frequently in this text.
7145 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7146 | It contains multiple lines with various patterns.
7147 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7148 | This helps test case-insensitive searching.
7149 | The quick brown fox jumps over the lazy dog.
7150 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7151 | Short patterns like ab should also be findable.
7152 | Single character patterns like 'a' appear frequently in this text.
7153 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7154 | It contains multiple lines with various patterns.
7155 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7156 | This helps test case-insensitive searching.
7157 | The quick brown fox jumps over the lazy dog.
7158 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7159 | Short patterns like ab should also be findable.
7160 | Single character patterns like 'a' appear frequently in this text.
7161 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7162 | It contains multiple lines with various patterns.
7163 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7164 | This helps test case-insensitive searching.
7165 | The quick brown fox jumps over the lazy dog.
7166 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7167 | Short patterns like ab should also be findable.
7168 | Single character patterns like 'a' appear frequently in this text.
7169 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7170 | It contains multiple lines with various patterns.
7171 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7172 | This helps test case-insensitive searching.
7173 | The quick brown fox jumps over the lazy dog.
7174 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7175 | Short patterns like ab should also be findable.
7176 | Single character patterns like 'a' appear frequently in this text.
7177 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7178 | It contains multiple lines with various patterns.
7179 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7180 | This helps test case-insensitive searching.
7181 | The quick brown fox jumps over the lazy dog.
7182 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7183 | Short patterns like ab should also be findable.
7184 | Single character patterns like 'a' appear frequently in this text.
7185 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7186 | It contains multiple lines with various patterns.
7187 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7188 | This helps test case-insensitive searching.
7189 | The quick brown fox jumps over the lazy dog.
7190 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7191 | Short patterns like ab should also be findable.
7192 | Single character patterns like 'a' appear frequently in this text.
7193 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7194 | It contains multiple lines with various patterns.
7195 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7196 | This helps test case-insensitive searching.
7197 | The quick brown fox jumps over the lazy dog.
7198 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7199 | Short patterns like ab should also be findable.
7200 | Single character patterns like 'a' appear frequently in this text.
7201 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7202 | It contains multiple lines with various patterns.
7203 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7204 | This helps test case-insensitive searching.
7205 | The quick brown fox jumps over the lazy dog.
7206 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7207 | Short patterns like ab should also be findable.
7208 | Single character patterns like 'a' appear frequently in this text.
7209 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7210 | It contains multiple lines with various patterns.
7211 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7212 | This helps test case-insensitive searching.
7213 | The quick brown fox jumps over the lazy dog.
7214 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7215 | Short patterns like ab should also be findable.
7216 | Single character patterns like 'a' appear frequently in this text.
7217 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7218 | It contains multiple lines with various patterns.
7219 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7220 | This helps test case-insensitive searching.
7221 | The quick brown fox jumps over the lazy dog.
7222 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7223 | Short patterns like ab should also be findable.
7224 | Single character patterns like 'a' appear frequently in this text.
7225 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7226 | It contains multiple lines with various patterns.
7227 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7228 | This helps test case-insensitive searching.
7229 | The quick brown fox jumps over the lazy dog.
7230 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7231 | Short patterns like ab should also be findable.
7232 | Single character patterns like 'a' appear frequently in this text.
7233 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7234 | It contains multiple lines with various patterns.
7235 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7236 | This helps test case-insensitive searching.
7237 | The quick brown fox jumps over the lazy dog.
7238 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7239 | Short patterns like ab should also be findable.
7240 | Single character patterns like 'a' appear frequently in this text.
7241 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7242 | It contains multiple lines with various patterns.
7243 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7244 | This helps test case-insensitive searching.
7245 | The quick brown fox jumps over the lazy dog.
7246 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7247 | Short patterns like ab should also be findable.
7248 | Single character patterns like 'a' appear frequently in this text.
7249 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7250 | It contains multiple lines with various patterns.
7251 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7252 | This helps test case-insensitive searching.
7253 | The quick brown fox jumps over the lazy dog.
7254 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7255 | Short patterns like ab should also be findable.
7256 | Single character patterns like 'a' appear frequently in this text.
7257 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7258 | It contains multiple lines with various patterns.
7259 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7260 | This helps test case-insensitive searching.
7261 | The quick brown fox jumps over the lazy dog.
7262 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7263 | Short patterns like ab should also be findable.
7264 | Single character patterns like 'a' appear frequently in this text.
7265 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7266 | It contains multiple lines with various patterns.
7267 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7268 | This helps test case-insensitive searching.
7269 | The quick brown fox jumps over the lazy dog.
7270 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7271 | Short patterns like ab should also be findable.
7272 | Single character patterns like 'a' appear frequently in this text.
7273 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7274 | It contains multiple lines with various patterns.
7275 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7276 | This helps test case-insensitive searching.
7277 | The quick brown fox jumps over the lazy dog.
7278 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7279 | Short patterns like ab should also be findable.
7280 | Single character patterns like 'a' appear frequently in this text.
7281 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7282 | It contains multiple lines with various patterns.
7283 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7284 | This helps test case-insensitive searching.
7285 | The quick brown fox jumps over the lazy dog.
7286 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7287 | Short patterns like ab should also be findable.
7288 | Single character patterns like 'a' appear frequently in this text.
7289 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7290 | It contains multiple lines with various patterns.
7291 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7292 | This helps test case-insensitive searching.
7293 | The quick brown fox jumps over the lazy dog.
7294 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7295 | Short patterns like ab should also be findable.
7296 | Single character patterns like 'a' appear frequently in this text.
7297 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7298 | It contains multiple lines with various patterns.
7299 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7300 | This helps test case-insensitive searching.
7301 | The quick brown fox jumps over the lazy dog.
7302 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7303 | Short patterns like ab should also be findable.
7304 | Single character patterns like 'a' appear frequently in this text.
7305 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7306 | It contains multiple lines with various patterns.
7307 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7308 | This helps test case-insensitive searching.
7309 | The quick brown fox jumps over the lazy dog.
7310 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7311 | Short patterns like ab should also be findable.
7312 | Single character patterns like 'a' appear frequently in this text.
7313 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7314 | It contains multiple lines with various patterns.
7315 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7316 | This helps test case-insensitive searching.
7317 | The quick brown fox jumps over the lazy dog.
7318 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7319 | Short patterns like ab should also be findable.
7320 | Single character patterns like 'a' appear frequently in this text.
7321 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7322 | It contains multiple lines with various patterns.
7323 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7324 | This helps test case-insensitive searching.
7325 | The quick brown fox jumps over the lazy dog.
7326 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7327 | Short patterns like ab should also be findable.
7328 | Single character patterns like 'a' appear frequently in this text.
7329 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7330 | It contains multiple lines with various patterns.
7331 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7332 | This helps test case-insensitive searching.
7333 | The quick brown fox jumps over the lazy dog.
7334 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7335 | Short patterns like ab should also be findable.
7336 | Single character patterns like 'a' appear frequently in this text.
7337 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7338 | It contains multiple lines with various patterns.
7339 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7340 | This helps test case-insensitive searching.
7341 | The quick brown fox jumps over the lazy dog.
7342 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7343 | Short patterns like ab should also be findable.
7344 | Single character patterns like 'a' appear frequently in this text.
7345 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7346 | It contains multiple lines with various patterns.
7347 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7348 | This helps test case-insensitive searching.
7349 | The quick brown fox jumps over the lazy dog.
7350 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7351 | Short patterns like ab should also be findable.
7352 | Single character patterns like 'a' appear frequently in this text.
7353 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7354 | It contains multiple lines with various patterns.
7355 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7356 | This helps test case-insensitive searching.
7357 | The quick brown fox jumps over the lazy dog.
7358 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7359 | Short patterns like ab should also be findable.
7360 | Single character patterns like 'a' appear frequently in this text.
7361 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7362 | It contains multiple lines with various patterns.
7363 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7364 | This helps test case-insensitive searching.
7365 | The quick brown fox jumps over the lazy dog.
7366 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7367 | Short patterns like ab should also be findable.
7368 | Single character patterns like 'a' appear frequently in this text.
7369 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7370 | It contains multiple lines with various patterns.
7371 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7372 | This helps test case-insensitive searching.
7373 | The quick brown fox jumps over the lazy dog.
7374 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7375 | Short patterns like ab should also be findable.
7376 | Single character patterns like 'a' appear frequently in this text.
7377 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7378 | It contains multiple lines with various patterns.
7379 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7380 | This helps test case-insensitive searching.
7381 | The quick brown fox jumps over the lazy dog.
7382 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7383 | Short patterns like ab should also be findable.
7384 | Single character patterns like 'a' appear frequently in this text.
7385 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7386 | It contains multiple lines with various patterns.
7387 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7388 | This helps test case-insensitive searching.
7389 | The quick brown fox jumps over the lazy dog.
7390 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7391 | Short patterns like ab should also be findable.
7392 | Single character patterns like 'a' appear frequently in this text.
7393 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7394 | It contains multiple lines with various patterns.
7395 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7396 | This helps test case-insensitive searching.
7397 | The quick brown fox jumps over the lazy dog.
7398 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7399 | Short patterns like ab should also be findable.
7400 | Single character patterns like 'a' appear frequently in this text.
7401 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7402 | It contains multiple lines with various patterns.
7403 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7404 | This helps test case-insensitive searching.
7405 | The quick brown fox jumps over the lazy dog.
7406 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7407 | Short patterns like ab should also be findable.
7408 | Single character patterns like 'a' appear frequently in this text.
7409 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7410 | It contains multiple lines with various patterns.
7411 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7412 | This helps test case-insensitive searching.
7413 | The quick brown fox jumps over the lazy dog.
7414 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7415 | Short patterns like ab should also be findable.
7416 | Single character patterns like 'a' appear frequently in this text.
7417 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7418 | It contains multiple lines with various patterns.
7419 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7420 | This helps test case-insensitive searching.
7421 | The quick brown fox jumps over the lazy dog.
7422 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7423 | Short patterns like ab should also be findable.
7424 | Single character patterns like 'a' appear frequently in this text.
7425 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7426 | It contains multiple lines with various patterns.
7427 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7428 | This helps test case-insensitive searching.
7429 | The quick brown fox jumps over the lazy dog.
7430 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7431 | Short patterns like ab should also be findable.
7432 | Single character patterns like 'a' appear frequently in this text.
7433 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7434 | It contains multiple lines with various patterns.
7435 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7436 | This helps test case-insensitive searching.
7437 | The quick brown fox jumps over the lazy dog.
7438 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7439 | Short patterns like ab should also be findable.
7440 | Single character patterns like 'a' appear frequently in this text.
7441 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7442 | It contains multiple lines with various patterns.
7443 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7444 | This helps test case-insensitive searching.
7445 | The quick brown fox jumps over the lazy dog.
7446 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7447 | Short patterns like ab should also be findable.
7448 | Single character patterns like 'a' appear frequently in this text.
7449 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7450 | It contains multiple lines with various patterns.
7451 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7452 | This helps test case-insensitive searching.
7453 | The quick brown fox jumps over the lazy dog.
7454 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7455 | Short patterns like ab should also be findable.
7456 | Single character patterns like 'a' appear frequently in this text.
7457 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7458 | It contains multiple lines with various patterns.
7459 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7460 | This helps test case-insensitive searching.
7461 | The quick brown fox jumps over the lazy dog.
7462 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7463 | Short patterns like ab should also be findable.
7464 | Single character patterns like 'a' appear frequently in this text.
7465 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7466 | It contains multiple lines with various patterns.
7467 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7468 | This helps test case-insensitive searching.
7469 | The quick brown fox jumps over the lazy dog.
7470 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7471 | Short patterns like ab should also be findable.
7472 | Single character patterns like 'a' appear frequently in this text.
7473 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7474 | It contains multiple lines with various patterns.
7475 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7476 | This helps test case-insensitive searching.
7477 | The quick brown fox jumps over the lazy dog.
7478 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7479 | Short patterns like ab should also be findable.
7480 | Single character patterns like 'a' appear frequently in this text.
7481 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7482 | It contains multiple lines with various patterns.
7483 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7484 | This helps test case-insensitive searching.
7485 | The quick brown fox jumps over the lazy dog.
7486 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7487 | Short patterns like ab should also be findable.
7488 | Single character patterns like 'a' appear frequently in this text.
7489 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7490 | It contains multiple lines with various patterns.
7491 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7492 | This helps test case-insensitive searching.
7493 | The quick brown fox jumps over the lazy dog.
7494 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7495 | Short patterns like ab should also be findable.
7496 | Single character patterns like 'a' appear frequently in this text.
7497 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7498 | It contains multiple lines with various patterns.
7499 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7500 | This helps test case-insensitive searching.
7501 | The quick brown fox jumps over the lazy dog.
7502 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7503 | Short patterns like ab should also be findable.
7504 | Single character patterns like 'a' appear frequently in this text.
7505 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7506 | It contains multiple lines with various patterns.
7507 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7508 | This helps test case-insensitive searching.
7509 | The quick brown fox jumps over the lazy dog.
7510 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7511 | Short patterns like ab should also be findable.
7512 | Single character patterns like 'a' appear frequently in this text.
7513 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7514 | It contains multiple lines with various patterns.
7515 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7516 | This helps test case-insensitive searching.
7517 | The quick brown fox jumps over the lazy dog.
7518 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7519 | Short patterns like ab should also be findable.
7520 | Single character patterns like 'a' appear frequently in this text.
7521 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7522 | It contains multiple lines with various patterns.
7523 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7524 | This helps test case-insensitive searching.
7525 | The quick brown fox jumps over the lazy dog.
7526 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7527 | Short patterns like ab should also be findable.
7528 | Single character patterns like 'a' appear frequently in this text.
7529 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7530 | It contains multiple lines with various patterns.
7531 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7532 | This helps test case-insensitive searching.
7533 | The quick brown fox jumps over the lazy dog.
7534 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7535 | Short patterns like ab should also be findable.
7536 | Single character patterns like 'a' appear frequently in this text.
7537 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7538 | It contains multiple lines with various patterns.
7539 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7540 | This helps test case-insensitive searching.
7541 | The quick brown fox jumps over the lazy dog.
7542 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7543 | Short patterns like ab should also be findable.
7544 | Single character patterns like 'a' appear frequently in this text.
7545 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7546 | It contains multiple lines with various patterns.
7547 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7548 | This helps test case-insensitive searching.
7549 | The quick brown fox jumps over the lazy dog.
7550 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7551 | Short patterns like ab should also be findable.
7552 | Single character patterns like 'a' appear frequently in this text.
7553 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7554 | It contains multiple lines with various patterns.
7555 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7556 | This helps test case-insensitive searching.
7557 | The quick brown fox jumps over the lazy dog.
7558 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7559 | Short patterns like ab should also be findable.
7560 | Single character patterns like 'a' appear frequently in this text.
7561 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7562 | It contains multiple lines with various patterns.
7563 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7564 | This helps test case-insensitive searching.
7565 | The quick brown fox jumps over the lazy dog.
7566 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7567 | Short patterns like ab should also be findable.
7568 | Single character patterns like 'a' appear frequently in this text.
7569 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7570 | It contains multiple lines with various patterns.
7571 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7572 | This helps test case-insensitive searching.
7573 | The quick brown fox jumps over the lazy dog.
7574 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7575 | Short patterns like ab should also be findable.
7576 | Single character patterns like 'a' appear frequently in this text.
7577 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7578 | It contains multiple lines with various patterns.
7579 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7580 | This helps test case-insensitive searching.
7581 | The quick brown fox jumps over the lazy dog.
7582 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7583 | Short patterns like ab should also be findable.
7584 | Single character patterns like 'a' appear frequently in this text.
7585 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7586 | It contains multiple lines with various patterns.
7587 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7588 | This helps test case-insensitive searching.
7589 | The quick brown fox jumps over the lazy dog.
7590 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7591 | Short patterns like ab should also be findable.
7592 | Single character patterns like 'a' appear frequently in this text.
7593 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7594 | It contains multiple lines with various patterns.
7595 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7596 | This helps test case-insensitive searching.
7597 | The quick brown fox jumps over the lazy dog.
7598 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7599 | Short patterns like ab should also be findable.
7600 | Single character patterns like 'a' appear frequently in this text.
7601 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7602 | It contains multiple lines with various patterns.
7603 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7604 | This helps test case-insensitive searching.
7605 | The quick brown fox jumps over the lazy dog.
7606 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7607 | Short patterns like ab should also be findable.
7608 | Single character patterns like 'a' appear frequently in this text.
7609 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7610 | It contains multiple lines with various patterns.
7611 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7612 | This helps test case-insensitive searching.
7613 | The quick brown fox jumps over the lazy dog.
7614 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7615 | Short patterns like ab should also be findable.
7616 | Single character patterns like 'a' appear frequently in this text.
7617 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7618 | It contains multiple lines with various patterns.
7619 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7620 | This helps test case-insensitive searching.
7621 | The quick brown fox jumps over the lazy dog.
7622 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7623 | Short patterns like ab should also be findable.
7624 | Single character patterns like 'a' appear frequently in this text.
7625 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7626 | It contains multiple lines with various patterns.
7627 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7628 | This helps test case-insensitive searching.
7629 | The quick brown fox jumps over the lazy dog.
7630 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7631 | Short patterns like ab should also be findable.
7632 | Single character patterns like 'a' appear frequently in this text.
7633 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7634 | It contains multiple lines with various patterns.
7635 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7636 | This helps test case-insensitive searching.
7637 | The quick brown fox jumps over the lazy dog.
7638 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7639 | Short patterns like ab should also be findable.
7640 | Single character patterns like 'a' appear frequently in this text.
7641 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7642 | It contains multiple lines with various patterns.
7643 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7644 | This helps test case-insensitive searching.
7645 | The quick brown fox jumps over the lazy dog.
7646 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7647 | Short patterns like ab should also be findable.
7648 | Single character patterns like 'a' appear frequently in this text.
7649 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7650 | It contains multiple lines with various patterns.
7651 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7652 | This helps test case-insensitive searching.
7653 | The quick brown fox jumps over the lazy dog.
7654 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7655 | Short patterns like ab should also be findable.
7656 | Single character patterns like 'a' appear frequently in this text.
7657 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7658 | It contains multiple lines with various patterns.
7659 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7660 | This helps test case-insensitive searching.
7661 | The quick brown fox jumps over the lazy dog.
7662 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7663 | Short patterns like ab should also be findable.
7664 | Single character patterns like 'a' appear frequently in this text.
7665 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7666 | It contains multiple lines with various patterns.
7667 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7668 | This helps test case-insensitive searching.
7669 | The quick brown fox jumps over the lazy dog.
7670 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7671 | Short patterns like ab should also be findable.
7672 | Single character patterns like 'a' appear frequently in this text.
7673 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7674 | It contains multiple lines with various patterns.
7675 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7676 | This helps test case-insensitive searching.
7677 | The quick brown fox jumps over the lazy dog.
7678 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7679 | Short patterns like ab should also be findable.
7680 | Single character patterns like 'a' appear frequently in this text.
7681 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7682 | It contains multiple lines with various patterns.
7683 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7684 | This helps test case-insensitive searching.
7685 | The quick brown fox jumps over the lazy dog.
7686 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7687 | Short patterns like ab should also be findable.
7688 | Single character patterns like 'a' appear frequently in this text.
7689 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7690 | It contains multiple lines with various patterns.
7691 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7692 | This helps test case-insensitive searching.
7693 | The quick brown fox jumps over the lazy dog.
7694 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7695 | Short patterns like ab should also be findable.
7696 | Single character patterns like 'a' appear frequently in this text.
7697 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7698 | It contains multiple lines with various patterns.
7699 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7700 | This helps test case-insensitive searching.
7701 | The quick brown fox jumps over the lazy dog.
7702 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7703 | Short patterns like ab should also be findable.
7704 | Single character patterns like 'a' appear frequently in this text.
7705 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7706 | It contains multiple lines with various patterns.
7707 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7708 | This helps test case-insensitive searching.
7709 | The quick brown fox jumps over the lazy dog.
7710 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7711 | Short patterns like ab should also be findable.
7712 | Single character patterns like 'a' appear frequently in this text.
7713 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7714 | It contains multiple lines with various patterns.
7715 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7716 | This helps test case-insensitive searching.
7717 | The quick brown fox jumps over the lazy dog.
7718 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7719 | Short patterns like ab should also be findable.
7720 | Single character patterns like 'a' appear frequently in this text.
7721 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7722 | It contains multiple lines with various patterns.
7723 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7724 | This helps test case-insensitive searching.
7725 | The quick brown fox jumps over the lazy dog.
7726 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7727 | Short patterns like ab should also be findable.
7728 | Single character patterns like 'a' appear frequently in this text.
7729 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7730 | It contains multiple lines with various patterns.
7731 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7732 | This helps test case-insensitive searching.
7733 | The quick brown fox jumps over the lazy dog.
7734 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7735 | Short patterns like ab should also be findable.
7736 | Single character patterns like 'a' appear frequently in this text.
7737 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7738 | It contains multiple lines with various patterns.
7739 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7740 | This helps test case-insensitive searching.
7741 | The quick brown fox jumps over the lazy dog.
7742 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7743 | Short patterns like ab should also be findable.
7744 | Single character patterns like 'a' appear frequently in this text.
7745 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7746 | It contains multiple lines with various patterns.
7747 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7748 | This helps test case-insensitive searching.
7749 | The quick brown fox jumps over the lazy dog.
7750 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7751 | Short patterns like ab should also be findable.
7752 | Single character patterns like 'a' appear frequently in this text.
7753 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7754 | It contains multiple lines with various patterns.
7755 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7756 | This helps test case-insensitive searching.
7757 | The quick brown fox jumps over the lazy dog.
7758 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7759 | Short patterns like ab should also be findable.
7760 | Single character patterns like 'a' appear frequently in this text.
7761 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7762 | It contains multiple lines with various patterns.
7763 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7764 | This helps test case-insensitive searching.
7765 | The quick brown fox jumps over the lazy dog.
7766 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7767 | Short patterns like ab should also be findable.
7768 | Single character patterns like 'a' appear frequently in this text.
7769 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7770 | It contains multiple lines with various patterns.
7771 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7772 | This helps test case-insensitive searching.
7773 | The quick brown fox jumps over the lazy dog.
7774 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7775 | Short patterns like ab should also be findable.
7776 | Single character patterns like 'a' appear frequently in this text.
7777 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7778 | It contains multiple lines with various patterns.
7779 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7780 | This helps test case-insensitive searching.
7781 | The quick brown fox jumps over the lazy dog.
7782 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7783 | Short patterns like ab should also be findable.
7784 | Single character patterns like 'a' appear frequently in this text.
7785 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7786 | It contains multiple lines with various patterns.
7787 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7788 | This helps test case-insensitive searching.
7789 | The quick brown fox jumps over the lazy dog.
7790 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7791 | Short patterns like ab should also be findable.
7792 | Single character patterns like 'a' appear frequently in this text.
7793 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7794 | It contains multiple lines with various patterns.
7795 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7796 | This helps test case-insensitive searching.
7797 | The quick brown fox jumps over the lazy dog.
7798 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7799 | Short patterns like ab should also be findable.
7800 | Single character patterns like 'a' appear frequently in this text.
7801 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7802 | It contains multiple lines with various patterns.
7803 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7804 | This helps test case-insensitive searching.
7805 | The quick brown fox jumps over the lazy dog.
7806 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7807 | Short patterns like ab should also be findable.
7808 | Single character patterns like 'a' appear frequently in this text.
7809 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7810 | It contains multiple lines with various patterns.
7811 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7812 | This helps test case-insensitive searching.
7813 | The quick brown fox jumps over the lazy dog.
7814 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7815 | Short patterns like ab should also be findable.
7816 | Single character patterns like 'a' appear frequently in this text.
7817 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7818 | It contains multiple lines with various patterns.
7819 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7820 | This helps test case-insensitive searching.
7821 | The quick brown fox jumps over the lazy dog.
7822 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7823 | Short patterns like ab should also be findable.
7824 | Single character patterns like 'a' appear frequently in this text.
7825 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7826 | It contains multiple lines with various patterns.
7827 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7828 | This helps test case-insensitive searching.
7829 | The quick brown fox jumps over the lazy dog.
7830 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7831 | Short patterns like ab should also be findable.
7832 | Single character patterns like 'a' appear frequently in this text.
7833 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7834 | It contains multiple lines with various patterns.
7835 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7836 | This helps test case-insensitive searching.
7837 | The quick brown fox jumps over the lazy dog.
7838 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7839 | Short patterns like ab should also be findable.
7840 | Single character patterns like 'a' appear frequently in this text.
7841 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7842 | It contains multiple lines with various patterns.
7843 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7844 | This helps test case-insensitive searching.
7845 | The quick brown fox jumps over the lazy dog.
7846 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7847 | Short patterns like ab should also be findable.
7848 | Single character patterns like 'a' appear frequently in this text.
7849 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7850 | It contains multiple lines with various patterns.
7851 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7852 | This helps test case-insensitive searching.
7853 | The quick brown fox jumps over the lazy dog.
7854 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7855 | Short patterns like ab should also be findable.
7856 | Single character patterns like 'a' appear frequently in this text.
7857 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7858 | It contains multiple lines with various patterns.
7859 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7860 | This helps test case-insensitive searching.
7861 | The quick brown fox jumps over the lazy dog.
7862 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7863 | Short patterns like ab should also be findable.
7864 | Single character patterns like 'a' appear frequently in this text.
7865 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7866 | It contains multiple lines with various patterns.
7867 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7868 | This helps test case-insensitive searching.
7869 | The quick brown fox jumps over the lazy dog.
7870 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7871 | Short patterns like ab should also be findable.
7872 | Single character patterns like 'a' appear frequently in this text.
7873 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7874 | It contains multiple lines with various patterns.
7875 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7876 | This helps test case-insensitive searching.
7877 | The quick brown fox jumps over the lazy dog.
7878 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7879 | Short patterns like ab should also be findable.
7880 | Single character patterns like 'a' appear frequently in this text.
7881 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7882 | It contains multiple lines with various patterns.
7883 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7884 | This helps test case-insensitive searching.
7885 | The quick brown fox jumps over the lazy dog.
7886 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7887 | Short patterns like ab should also be findable.
7888 | Single character patterns like 'a' appear frequently in this text.
7889 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7890 | It contains multiple lines with various patterns.
7891 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7892 | This helps test case-insensitive searching.
7893 | The quick brown fox jumps over the lazy dog.
7894 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7895 | Short patterns like ab should also be findable.
7896 | Single character patterns like 'a' appear frequently in this text.
7897 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7898 | It contains multiple lines with various patterns.
7899 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7900 | This helps test case-insensitive searching.
7901 | The quick brown fox jumps over the lazy dog.
7902 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7903 | Short patterns like ab should also be findable.
7904 | Single character patterns like 'a' appear frequently in this text.
7905 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7906 | It contains multiple lines with various patterns.
7907 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7908 | This helps test case-insensitive searching.
7909 | The quick brown fox jumps over the lazy dog.
7910 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7911 | Short patterns like ab should also be findable.
7912 | Single character patterns like 'a' appear frequently in this text.
7913 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7914 | It contains multiple lines with various patterns.
7915 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7916 | This helps test case-insensitive searching.
7917 | The quick brown fox jumps over the lazy dog.
7918 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7919 | Short patterns like ab should also be findable.
7920 | Single character patterns like 'a' appear frequently in this text.
7921 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7922 | It contains multiple lines with various patterns.
7923 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7924 | This helps test case-insensitive searching.
7925 | The quick brown fox jumps over the lazy dog.
7926 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7927 | Short patterns like ab should also be findable.
7928 | Single character patterns like 'a' appear frequently in this text.
7929 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7930 | It contains multiple lines with various patterns.
7931 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7932 | This helps test case-insensitive searching.
7933 | The quick brown fox jumps over the lazy dog.
7934 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7935 | Short patterns like ab should also be findable.
7936 | Single character patterns like 'a' appear frequently in this text.
7937 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7938 | It contains multiple lines with various patterns.
7939 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7940 | This helps test case-insensitive searching.
7941 | The quick brown fox jumps over the lazy dog.
7942 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7943 | Short patterns like ab should also be findable.
7944 | Single character patterns like 'a' appear frequently in this text.
7945 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7946 | It contains multiple lines with various patterns.
7947 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7948 | This helps test case-insensitive searching.
7949 | The quick brown fox jumps over the lazy dog.
7950 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7951 | Short patterns like ab should also be findable.
7952 | Single character patterns like 'a' appear frequently in this text.
7953 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7954 | It contains multiple lines with various patterns.
7955 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7956 | This helps test case-insensitive searching.
7957 | The quick brown fox jumps over the lazy dog.
7958 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7959 | Short patterns like ab should also be findable.
7960 | Single character patterns like 'a' appear frequently in this text.
7961 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7962 | It contains multiple lines with various patterns.
7963 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7964 | This helps test case-insensitive searching.
7965 | The quick brown fox jumps over the lazy dog.
7966 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7967 | Short patterns like ab should also be findable.
7968 | Single character patterns like 'a' appear frequently in this text.
7969 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7970 | It contains multiple lines with various patterns.
7971 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7972 | This helps test case-insensitive searching.
7973 | The quick brown fox jumps over the lazy dog.
7974 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7975 | Short patterns like ab should also be findable.
7976 | Single character patterns like 'a' appear frequently in this text.
7977 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7978 | It contains multiple lines with various patterns.
7979 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7980 | This helps test case-insensitive searching.
7981 | The quick brown fox jumps over the lazy dog.
7982 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7983 | Short patterns like ab should also be findable.
7984 | Single character patterns like 'a' appear frequently in this text.
7985 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7986 | It contains multiple lines with various patterns.
7987 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7988 | This helps test case-insensitive searching.
7989 | The quick brown fox jumps over the lazy dog.
7990 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7991 | Short patterns like ab should also be findable.
7992 | Single character patterns like 'a' appear frequently in this text.
7993 | We need to test boundaries as well, so here's some text at the end.This is a sample text file for testing the krep-mcp-server.
7994 | It contains multiple lines with various patterns.
7995 | Some patterns appear multiple times, like pattern, PATTERN, and Pattern.
7996 | This helps test case-insensitive searching.
7997 | The quick brown fox jumps over the lazy dog.
7998 | We also have some longer patterns like abcdefghijklmnopqrstuvwxyz.
7999 | Short patterns like ab should also be findable.
8000 | Single character patterns like 'a' appear frequently in this text.
8001 | We need to test boundaries as well, so here's some text at the end.
```