To build a good MCP server you need to think about how the LLM will interact with your tools.
An MCP Server is not simply an API wrapper, though it can be.
However, if its an API wrapper its often lackluster in capability unless the API is comprehensive with features.
In an MCP Server, the tool descriptions, filter options, expected input values, etc all matter greatly. Natural language interactions is what matter here. The tool description of what it does and input values etc is critical.
Tools such as "find_projects" instead of a restful "list projects" is far more useful to an LLM.
Why? Users are asking questions, often about sets or subsets of data. Sometimes thats one record, sometimes thats multiple records. The LLM wants to find/search for things not paginate through pages and pages of data.
Plus pagination is slow and returns tons of data. Pagination is a token monster, it will eat up your context window, so you have to be careful.
Examples:
- User Initiated: "How many projects started in 2025, and already have already been completed"?
- Agent Initiated: "I need to find all projects that reference work item 3351 that were completed in 2025" (e.g. - via Cursor, Claude Code, etc).
If your MCP tool has a filter for `created at` with relational comparison operators (>, =, <, etc) and another filter for status, you can get this data easily with minimal context window impact (if your result is small).
Then with an additional tool to return a single record, `get_project` (that returns the full dataset of the project) you can provide the LLM with tools so it can find and read the data it needs without exhausting its context window.
Example: The LLM returns many projects that were completed. One catches the eye of the user. So they ask "For project `Make it Rain` can you give me the details about it?"
The LLM would then go get the project with the `get_project` MCP tool (or resource - though beware, not all MCP clients fully support resources yet) and show you the data.
While all of this is possible with an API that has a good domain model surface area, its not always possible as many API's are simply REST CRUD operations. Nothing wrong with that, but it makes it more challenging at times.
The moral of the story here is that you have to think about modeling your interactions with MCP tools as if you were telling someone "Hey, here's what I can do for you, and here's how you can ask me about it, and then here's the kind of data you'll get back". Then the LLM can decide "oh I want to use tool x this time, and for details I'll use tool y".
In find/search operations, don't return too much data, just as much as needed for the main use cases of your app. Then provide a tool that the LLM can use go get more data for that particular record, if and when it needs it. This will will keep the MCP tool snappy, keep the context window consumption to a minimum and allow the LLM to get the data it needs when it needs it.
• • •
Missing some Tweet in this thread? You can try to
force a refresh
When asked if you have any questions for the interviewer at the end of a job interview, say yes and ask this:
“No job is perfect ... what do you dislike about working here?”
You’ll get pure honesty or absolute lies.
This question almost always throws the interviewer off balance.
They’re not ready for it and most don’t know how to answer it, which is why most of the time you’ll get honest feedback or obvious studdering lies.
I’ve been using this exact tactic for 15+ years.
It works every single time.
99% of the time the honest folks were indeed honest. I know this because I would experience the same negative aspects once employed at said employer (even if it was just something minor).
I'm not convinced that Android multi-module projects are the way to go anymore.
I'm finding gradle indexing, building and rebuilding is taking up the majority of my day now. It feels like
I'm barely coding anymore and just waiting for the tools to catch up.
I appreciate the hardwork that is put into these tools, but at this point I'm starting to hate developing for Android with large projects. With small projects its a breeze.
The solution? I think it might be putting modules into a maven repo and publishing artifacts.
Then when you need them, pull in the artifacts like you do with AppCompat, etc. Use what you need.
If it changes, update the version code, reimport. All done.