Skip to main content

Loading…

Skip to main content
HomeProjectsPostsContact
Justin Tsugranes LogoJustin Tsugranes Logo

Justin Tsugranes

HomeProjectsPostsContact

Stay in the loop

Occasional notes on what I'm building, lessons earned, and the studio behind it.

By subscribing, you agree to receive No spam. Unsubscribe in one click anytime. from Justin Tsugranes. No spam. Unsubscribe anytime. Privacy Policy

© 2026 Total Ventures LLC. All rights reserved.

Privacy PolicyTerms of ServiceCookie Policy
MCP Server Tutorial: When to Build, How to Scope | Justin Tsugranes | Justin Tsugranes
Xinf
MCP Server Tutorial: When to Build, How to Scope
←Posts

Building & Operating

MCP Server Tutorial: When to Build, How to Scope

Not every integration needs a custom MCP server. Here's how to decide when to build one, how to scope the tools, and what shipping it actually looks like.

Justin Tsugranes·April 28, 2026·6 min read
On this page
  1. What an MCP Server Actually Does
  2. When You Don't Need a Custom MCP Server
  3. When to Build a Custom MCP Server
  4. How to Scope the Tools
  5. One Tool, One Responsibility
  6. Name and Describe Like the Model Is Reading It
  7. Keep Input Schemas Tight
  8. Separate Read from Write
  9. A Concrete Example: A Studio Operations Server
  10. The Transport Question
  11. What Shipping Looks Like
  12. Build the Right Thing First

MCP Server Tutorial: When to Build One and How to Scope the Tools

Most MCP server tutorials start with setup. This one starts with the question you should ask first: does this problem actually warrant a custom server?

The answer is often no. And building when you shouldn't is the fastest way to add maintenance weight to a system that was supposed to reduce it.

Here's how I think about it — from inside a studio where agents are handling research, ops, content, monitoring, and parts of deployment, and where the tooling decisions compound over time.

---

What an MCP Server Actually Does

Model Context Protocol is Anthropic's open standard for giving language models structured access to tools, resources, and prompts. An MCP server exposes capabilities — a set of typed functions the model can call — over a defined transport layer.

The practical upshot: instead of jamming a blob of context into a system prompt and hoping the model infers what to do with it, you give the model a clean interface. It calls the tool. The tool returns structured data. The model uses it.

This is better than prompt-stuffing for the same reason an API is better than scraping. The interface is intentional. The schema is enforced. The failure modes are predictable.

But that structure comes with a cost. You're writing a server. You're maintaining a schema. You're handling transport and errors and version drift. If the problem doesn't justify that, reach for something simpler.

---

When You Don't Need a Custom MCP Server

Before the mcp server tutorial part, the honest answer to "should I build this?"

Use an existing server if one covers the domain. The ecosystem has grown fast. File system, GitHub, Postgres, Slack, Notion, web search — there are maintained servers for most common integrations. Check before you build.

Use a prompt + function call if the operation is narrow and stable. If you're doing one thing once, a well-scoped system prompt with a single function definition is faster to ship and easier to reason about. You don't need a server for every tool.

Use a retrieval layer if the problem is knowledge, not action. If your agent needs context from a document store or a knowledge base, a RAG pipeline with vector search is more appropriate than an MCP server. Servers are for doing things, not for knowing things.

The signal that you actually need a custom server: you're building something domain-specific that no existing server covers, you need multiple related tools that share state or context, or you're building something that will be reused across multiple agents in your system.

---

When to Build a Custom MCP Server

Three conditions that, together, make a strong case:

  1. The capability is proprietary. Internal APIs, custom data models, business logic that doesn't exist anywhere else. No off-the-shelf server covers it because the domain is yours.
  1. Multiple tools share context. If you're building three tools that all operate on the same underlying resource — say, a project management system where you need to read tasks, update status, and create subtasks — a server lets you share connection state, auth, and error handling across all of them. Building them as isolated function calls means duplicating that infrastructure.
  1. You're reusing it across agents. If the same capability needs to be available to more than one agent in your system, a server gives you a single implementation to maintain. Duplication across agents is how systems rot.

If you're hitting all three, build the server. If you're hitting one, think harder.

---

How to Scope the Tools

This is where most tutorials skip the hard part. Scoping tools is the job. Get it wrong and your server is either too broad to be reliable or too narrow to be useful.

One Tool, One Responsibility

Each tool should do one thing and do it completely. Not "manage tasks" — that's a domain. "Create a task with a given title, project ID, and due date" — that's a tool.

The model decides which tool to call. Give it clean, non-overlapping options. Ambiguity in tool scope shows up as hallucinated calls and wrong parameters.

Name and Describe Like the Model Is Reading It

Because it is. The tool name and description are the model's interface. Be literal. "get_project_tasks" is better than "fetch_tasks" because it's unambiguous about what kind of tasks and where they come from. The description should explain what the tool does, what it returns, and any non-obvious constraints — not what the underlying API looks like.

Keep Input Schemas Tight

Every optional parameter is a decision the model has to make. When you're scoping, ask: does the model need to set this, or can I default it server-side? Push decisions down to the server wherever the answer is obvious. The narrower the input schema, the more reliable the calls.

Separate Read from Write

Read tools and write tools should always be distinct. This isn't just good API design — it gives you clean permission boundaries. An agent that only needs to read data from a system should never have access to a write tool. Design for least-privilege from the start.

---

A Concrete Example: A Studio Operations Server

Here's a real-shaped problem. I run seven products. Each has a status — what's live, what's in progress, what's blocked. I want an agent to be able to query and update that status without me being in the loop.

What the server exposes:

  • \get_product_status(product_id)\ — returns current status, last updated, and any blocking notes
  • \update_product_status(product_id, status, note)\ — writes a new status with a timestamped note
  • \list_products()\ — returns the full product list with IDs and current status
  • \get_blocked_products()\ — returns only products with a blocked status

Four tools. Shared connection to the underlying store. Clean separation between reads and writes. The agent running weekly ops reviews calls these directly — no prompt engineering needed to get the data into context, no brittle string parsing to extract it.

That's the shape of a well-scoped server: small, specific, purpose-built, reusable.

---

The Transport Question

For local agents and development, stdio transport is the right default. Simple, low-overhead, easy to debug.

For agents that run in the cloud or need to be accessed remotely, SSE (Server-Sent Events) or the newer Streamable HTTP transport is the move. If you're building a server that needs to be available to multiple clients, design for HTTP from the start — retrofitting transport is annoying.

This is a decision worth making intentionally upfront. I've learned the hard way that "I'll figure out transport later" means refactoring a working server under deadline.

---

What Shipping Looks Like

A custom MCP server is a piece of infrastructure. Treat it like one.

  • Version it. Schema changes break agent behavior in ways that are hard to debug if you don't have a clear change history.
  • Test the tools in isolation before wiring them to an agent. The MCP Inspector is useful here — call each tool directly, verify the output schema, check the error paths.
  • Log inputs and outputs during early operation. You'll see what the model is actually calling vs. what you expected it to call. Those gaps tell you where the tool descriptions need work.
  • Document the intended use case for each tool. Not for the model — for you, six months from now, when you've forgotten why you made the scoping decisions you made.

The goal is a server that's boring to operate. Boring means reliable.

---

Build the Right Thing First

The best mcp server tutorial is the one that starts with restraint. The technology is not the hard part. Deciding what to build, scoping it correctly, and shipping something that holds up — that's the work.

If you're standing up your first agentic system and trying to figure out where custom tooling fits, The Builder's Playbook walks through how the studio is architected — agent roles, tool design, the operating layer underneath it all. It's the implementation detail, not the theory.

If you've got a specific server design problem or you're trying to figure out whether your system needs custom tooling at all, book a 1:1. We'll work through it.

RecommendedFree

Free download

Get the Launch Checklist →
If this resonated

The studio is where the rest of it lives.

Total Ventures is the umbrella — the products, the resources, the strategy session.

totalventures.io
  • Resources

    Launch Checklist + the Builder’s Playbook bundle.

  • Strategy session

    A focused hour on your repo, stack, and monetization.

  • The brands

    The portfolio of products I’m building, end to end.

Studio Notes

How I’m building the studio.

The operator’s log — systems, decisions, and what’s working.

JT

Written by

Justin Tsugranes

Founder, Total Ventures

Solo-founder building a multi-brand product studio with AI agents. Writing about building, operating, and shipping.

ShareXLinkedInFacebook
#mcp#model context protocol#agentic engineering#ai agents#tool design#studio ops#shipping

On this page

  1. What an MCP Server Actually Does
  2. When You Don't Need a Custom MCP Server
  3. When to Build a Custom MCP Server
  4. How to Scope the Tools
  5. One Tool, One Responsibility
  6. Name and Describe Like the Model Is Reading It
  7. Keep Input Schemas Tight
  8. Separate Read from Write
  9. A Concrete Example: A Studio Operations Server
  10. The Transport Question
  11. What Shipping Looks Like
  12. Build the Right Thing First