MCP Tools: Essential Utilities for AI Coding Agents
MCP tools are the named functions an MCP server exposes to your AI coding agent, such as run_query, create_issue, or pinvari_next_instruction, which the agent discovers at startup and then calls by name with typed arguments. The essential ones cover the work an agent does constantly: reading your filesystem, touching git and GitHub, querying a database, searching the web, and pulling real screen context on a Mac.
Most "best MCP servers" roundups read like an app store ranked by stars. A better filter is friction removed per tool, because every server you bolt on is one more surface the model can call at the wrong moment.
What are MCP tools, exactly?
A tool is one callable function inside an MCP server. It has a name, a description, and a JSON schema for its arguments, and the server returns a structured result when the agent invokes it.
Tools are one of three things a server can offer. The other two are resources (readable data the client pulls in as context, like a file or a schema) and prompts (reusable templates). When people say the phrase loosely they mean the whole server, but precisely it is the callable surface.
The wire protocol is JSON-RPC 2.0. The agent sends tools/list to discover what exists, then tools/call with a name and arguments when the model decides to use one. A tool call returns either a structured result or an error with a message, so a well-built server lets the agent retry or fall back instead of hallucinating success.
If you want the ground-up version, see what an MCP server is and how the Model Context Protocol works.
The model does not read your code to learn a tool. It reads the tool's name, description, and argument schema at runtime. Vague names and loose schemas are the top cause of an agent calling the wrong tool.
Which MCP tools should you actually install?
Start with the servers that remove friction you hit every hour, not the ones with the longest feature list. For a coding agent on a Mac, that is a short list.
| Server | Representative tools | Transport | Why it earns a slot |
|---|---|---|---|
| Filesystem | read_file, write_file, list_dir | stdio | The agent edits real files instead of guessing paths |
| Git / GitHub | create_pr, list_issues, get_diff | stdio / HTTP | Turns "open a PR" into one call, not a shell dance |
| Database | run_query, describe_table | stdio | Reads your real schema so generated SQL compiles |
| Web search / fetch | search, fetch_url | HTTP | Pulls current docs the model was not trained on |
| Screen context (PinVari) | pinvari_next_instruction, pinvari_mark_done | local (127.0.0.1) | Hands the agent the exact UI element you pointed at |
The filesystem and git servers are close to non-negotiable, because without them the model reasons about your project from memory and pasted snippets. A database server closes the next gap, giving you generated SQL that compiles against your real schema instead of an imagined one. Web fetch covers the training-cutoff blind spot. Screen context is the piece most setups are missing, and it is the one that turns "the second button looks wrong" into an unambiguous instruction.
That set doubles as a list of clean MCP server examples to study when you build your own, because each has a narrow job and returns structured data.
Cap your active tool count. A tight set of ten reliable tools beats forty that overlap, because the model picks from names alone and near-duplicates are where it fumbles. Disable servers you are not using this week.
How do you find a good MCP server list?
There are public directories now, and searching for an mcp server list returns registries that index hundreds of servers by category. They are useful for discovery and dangerous as a shopping spree.
Treat any mcp server list the way you treat npm. Read the code, check who maintains it, and prefer servers that run locally over ones that phone home with your project context. A registry entry is a lead, not a recommendation.
For a curated take aimed at one agent, the best MCP servers for Claude Code writeup is a tighter filter than any raw index, because it ranks by real friction removed rather than popularity.
What does a local MCP server add on a Mac?
A local MCP server runs on 127.0.0.1 and never leaves your machine, which matters when the tool is reading your screen or your files. You add one with a single line:
claude mcp add pinvariThat registers PinVari, a native macOS server. Hold ⌥⌘A, circle or point at any on-screen element, and speak. It screenshots, transcribes on-device, and resolves the exact accessibility element you circled through AXUIElementCopyElementAtPosition, returning its role, label, and frame with a confidence score and circled-versus-dwelled provenance.
The agent-facing tool pinvari_next_instruction then returns the resolved element path, your spoken instruction, the region you circled, and a screenshot cropped to that region. pinvari_mark_done closes it.
On AX-blind surfaces like a canvas or some Electron windows, PinVari sets AXManualAccessibility and retries until a labeled element appears, then falls back to on-device Vision OCR when the accessibility tree stays empty. That is the honest limit: the tree is not always populated, so the tool degrades gracefully instead of pretending.
Everything is on-device, no API keys, nothing uploaded by default, and you bring your own agent. The deeper argument is in how a local MCP server gives an agent screen context.
How do you write a good MCP tool?
If you build your own server, the whole game is making tools the model calls correctly. Three habits do most of the work.
First, name the tool for the job, not the implementation. create_linear_issue tells the model when to reach for it; do_action does not. The name and description are the only signal the model has at call time.
Second, keep arguments strict. A tight JSON schema with required fields and enums stops the model from inventing shapes, and it turns a bad call into a clean validation error instead of a silent wrong result.
Third, return structured content, not prose. Give back fields the agent can read directly, and set the error flag with a message when something fails so the agent can retry or fall back. A tool that returns a paragraph forces the model to re-parse its own output, which is where multi-step runs drift.
The same rules explain why a screen-context tool is worth building carefully. It has one job, a strict result shape, and it returns a resolved element rather than a wall of text the model has to interpret.
Why do the best MCP tools resolve meaning, not just relay data?
The design difference between a mediocre tool and a great one is where the work happens. A weak tool ships raw material and makes the model reconstruct meaning; a strong tool resolves meaning on your side and hands over something already structured.
A screenshot tool ships pixels and hopes the model guesses which button you meant. A screen-context tool ships a named element the agent can act on with a confidence score attached. Same domain, opposite contract.
Below a confidence threshold, a good tool asks rather than silently guesses. PinVari asks when resolution drops under 0.8 instead of handing your agent a wrong element. A tool that always sounds certain is a tool that will occasionally be confidently wrong.
That principle scales to every server you install. Give each tool a narrow, well-named job, and return structured results rather than prose the model has to re-parse. If a screen-context tool is the piece missing from your Mac setup, PinVari is a one-time purchase rather than a subscription, and the details are on the pricing page.
FAQ
What is an MCP tool?
An MCP tool is a single named function that an MCP server exposes to an AI agent, with a description and a typed argument schema. The agent discovers it through tools/list and runs it through tools/call, then receives a structured result.
What is an MCP server in plain terms?
An MCP server is a small program that advertises a set of tools, resources, and prompts over a standard protocol. Any compatible agent can connect, list what the server offers, and call it without custom, model-specific glue code.
What are the best MCP tools to start with?
A filesystem server, a git or GitHub server, your database, a web fetch or search server, and a screen-context server on a Mac. That set covers most of what a coding agent needs while keeping the tool surface small.
Are there safe MCP server examples to learn from?
Yes. The official reference servers for filesystem, git, and fetch are good MCP server examples because they are small, well-documented, and show the tools-plus-schema pattern clearly. Read those before writing your own.
Do MCP tools work with a local model?
Yes. The protocol is model-agnostic, so the same tools work with a hosted model or a local one served through Ollama. The agent still lists and calls tools by name; only the model behind the client changes.
Where do I find a full MCP server list?
Public MCP registries index servers by category and are the fastest way to browse what exists. Treat every entry as a lead to vet yourself, and prefer local servers over ones that transmit your project context off the machine.
Hand your agent the exact element
PinVari resolves what you point at into a named, executable instruction — on-device, no keys, your own agent. If you run Claude Code, it is one command.
claude mcp add pinvariGet PinVari — $39 →
