# MCP Knowledge: Simple Beats Complex When AI Thinks

> Source: <https://dev.to/kevinten10/-mcp-knowledge-simple-beats-complex-when-ai-thinks-11gf>
> Published: 2026-06-25 08:12:09+00:00

Honestly, I built this knowledge base back in 2019. That's seven years of tinkering. I've gone from "this is the ultimate second brain that will change my life" to... well, after 1,847 hours and 99.4% negative ROI, I finally got something that actually works. And guess what? It's dead simple.

The turning point wasn't adding another fancy AI model or a better vector database. The turning point was adding MCP. And once I added MCP, everything got simpler. Not more complex. Simpler.

Let me walk you through what changed, why it changed, and why you don't need all that fancy stuff you think you do.

Back in the day, I built this big complex system. I had:

And honestly, it worked... kind of. But it was slow. It was complex. It broke in weird ways. And I spent more time maintaining it than actually using it.

The worst part? Every time I asked it a question, it would do all this work up front, generate embeddings, search, rank, summarize, and then give me a big block of text that I then had to copy-paste into Claude anyway.

Wait a minute. I was doing all this work to give AI the answer, just so AI could re-answer it. That's redundant. That's stupid. Why was I doing that?

Then MCP came along. And everything flipped.

With MCP, AI does the thinking. My server doesn't need to do the thinking anymore. My server just needs to give AI the raw data it asks for. That's it.

So I threw out:

What did I keep?

```
@RestController
@RequestMapping("/mcp")
public class McpServerController {

    private final KnowledgeRepository knowledgeRepository;

    public McpServerController(KnowledgeRepository knowledgeRepository) {
        this.knowledgeRepository = knowledgeRepository;
    }

    @Tool(description = "Search knowledge base for matching articles")
    public List<KnowledgeArticle> search(@Param(description = "Search query text") String query) {
        // Literally just: contains search
        return knowledgeRepository.findAll()
                .filter(article -> 
                    article.getTitle().toLowerCase().contains(query.toLowerCase()) ||
                    article.getContent().toLowerCase().contains(query.toLowerCase()))
                .limit(50)
                .toList();
    }

    @Tool(description = "Get full article content by ID")
    public String getArticle(String articleId) {
        return knowledgeRepository.findById(articleId)
                .map(article -> article.getTitle() + "\n\n" + article.getContent())
                .orElse("Article not found");
    }

    @ListTools
    public List<ToolInfo> listTools() {
        return List.of(ToolInfo.from(this));
    }
}
```

That's literally it. 80 lines of code. That's the whole server. Well, okay, you need some config for CORS and dependency injection, but that's it.

No embeddings. No vector database. No fancy ranking. Just `string.contains()`

search. That's it.

Honestly, it works better than the old complex system. Here's why:

**AI already understands what you're looking for** — When your AI client is connected via MCP, it knows the question you asked. It knows what context it needs. It can pick and choose which raw results are actually relevant better than my old ranking system could. Because it has the original question context. I didn't have that context in my old server-side ranking.

**You get the full original content** — My old system would summarize articles for you, but summaries lose details. Now AI gets the full article if it needs it, and can pick out the relevant bits itself. More accurate, less lost information.

**It's impossible to outrank AI** — AI already has the context of the entire conversation. It knows what you're trying to build, what you already tried, what you need next. Any server-side ranking I do can't compete with that context.

**It's dead simple to maintain** — No embedding model to update. No vector database to maintain. No indexes to rebuild when you add a note. Just add a note to the database, done.

Let's be honest, this approach isn't for everyone. Here's what works and what doesn't.

`string.contains()`

is fast enough for thousands of notes.`string.contains()`

will be slow. But who has millions of personal notes that are actually useful? I have 2847 notes, and it's instant.`string.contains()`

won't find it. But AI is pretty good at understanding what you meant anyway if you give it the list of titles. And honestly, I misspell things anyway, vector search doesn't find them either.I have 2,847 articles in my knowledge base. Let's compare before and after:

| Metric | Old Complex System | New Simple MCP System |
|---|---|---|
| Lines of Code | ~1200 | ~80 |
| Response Time | 2-5 seconds | 200-500ms |
| Maintenance Time/Month | 4-6 hours | < 30 minutes |
| Monthly Cost | $12-$18 | $2-$3 |
| Answer Quality | 7/10 | 9/10 |

I'm not kidding. The simple system scores higher on answer quality than the complex system I spent years building. Because the AI does the heavy lifting now. That's the trick.

I spent 7 years building this complex thing that didn't really work that well. Then I threw away 90% of the code because of a protocol change, and now it works better. That's embarrassing. But it's true.

The embarrassing truth is that MCP didn't just change how clients connect to my server. It changed what my server needs to do. And the answer was "do less".

I fell for the classic trap: "more AI = better". The truth was "move the AI work to where the AI already is, and keep your server simple".

No, of course not. If you have 100k+ notes, you need something better than `string.contains()`

. If you need full-text search with stemming and fuzzy matching, you should add that. But do you need it on the server, or can AI do the heavy lifting?

With MCP, AI already has the intelligence. You just need to give it the raw documents it asks for. That's it.

I'm not saying vector embeddings are never useful. I'm saying for a personal knowledge base connected via MCP, you don't need them. The AI already does all that work. Why duplicate it?

If you're building an MCP knowledge base for personal use, start here. Start with this simple version. It works. You can always add complexity later if you actually need it. I bet you don't need it.

Here's what I tell anyone who asks:

`string.contains()`

search, done.Have you built an MCP knowledge base? Did you try putting all the intelligence on the server, only to realize you're just duplicating work that AI already does? Did you simplify after adding MCP, or are you still carrying around all that complex infrastructure you don't really need? Drop a comment below and share your experience!

*This article is about the **Papers** project — a 7-year journey building a personal knowledge base, now optimized for MCP. Check out the [project on GitHub](https://github.com/kevinten10/Papers) to see the full code, including this simple MCP server implementation that actually works.