AgenticMCP Servers

MCP
Servers

Typed bridges from Claude to any tool. Two servers built from scratch in TypeScript and Zod, ten and more wired in as clients, and the agent treats them all the same.

Second Brain MCPCustom-built9 tools · Obsidian vault

Primer

What MCP actually is

MCP — Model Context Protocol is Anthropic's open standard for how AI clients talk to tools. A server exposes named tools with typed inputs; any MCP-capable client calls them like functions, and the contract stays the same if I swap the model underneath.

Clientcalls them like functions
Serverexposes named tools with typed inputs
The contract stays the same if I swap the model underneath.

Every surface

The MCP landscape

Two servers I built from scratch; the rest are official, vendor, or community servers I wire in. Each turns a system into a typed surface Claude can query and drive, and the agent treats them all the same.

Non-exhaustive — the set grows as new servers ship. Because every integration speaks MCP, adding a new one is a mcpServers config entry, not a code change.

Custom-builtfrom scratch

  • Make.com MCP19 tools · 5 groups
  • Second Brain MCP9 tools · Obsidian vault
Both spec sheets

Project & Task Management4 servers

  • AsanaTasks, projects, sections, tags
  • LinearIssues, cycles, roadmap
  • Atlassian / JiraTickets, sprints, boards
  • NotionPages, databases · ×3 workspaces

Design & Creative4 servers

  • FigmaFiles, frames, component inspection
  • ExcalidrawDiagrams, whiteboards, export
  • StitchScreen generation, design systems
  • Magic (21st.dev)UI component generation

Research & Documents2 servers

  • NotebookLMNotebooks, sources, research queries
  • Google DriveFiles, folders, shared docs

Browser & Context1 server

  • ArcOpen tabs, bookmarks, browsing context

Automation & Workflows2 servers

  • n8nSelf-hosted workflow runner · webhook-triggered from MCP tool calls on other servers
  • Claude.ai nativeFirst-party MCP bridges for Asana, Linear, Notion, Drive · zero-config

Request lifecycle

One tool call, there and back

Press play and follow the message: from Claude Code over MCP to the server, through validation to its target, and home as an answer.

  1. Claude Codethe client
  2. MCPJSON-RPC over stdio
  3. ServerTypeScript + Zod
  4. Obsidian vaultMarkdown on disk

1/6You ask Claude

request →

What do my notes say about writing tool descriptions?

Step 1 of 6: You ask Claude

Tool explorer

Pick a tool, see its contract

Choose one of the two servers I built and one of its tools. You see what Claude has to send and what comes back.

1Choose a server

2Choose a tool

vault_recall

read-only

Finds the notes a task needs, semantic and keyword search combined.

Claude sendsexample arguments
  • taskstring · required

    The task in plain language

    "writing tool descriptions"
  • projectstring · optional

    Only notes of this project

    not sent
  • limitnumber · default 5

    Max results

    3
Comes backexample result
{
  "notes": [
    {
      "path": "02-knowledge/mcp/descriptions.md",
      "title": "Field descriptions are the prompt",
      "score": 0.82,
      "type": "learning"
    }
  ],
  "recall_summary": "1 relevante Notes: 1 learning"
}

RunshybridSearch(semanticResults, keywordResults, limit)second-brain/.mcp-server/src/index.ts

Two servers, built from scratch

Architecture

Both servers are long-lived TypeScript processes on the official @modelcontextprotocol/sdk, with a thin adapter per target. Make wraps a REST API as 19 tools across 5 groups; Second Brain wraps an Obsidian vault as 9. Every input is Zod-validated before it runs, so a bad call fails here, not in the API.

The SDK handles transport, capability negotiation, and schema export, so the server code is just business logic. Claude Code finds the servers through the mcpServers config block and exposes each tool to the model as a callable function.

0
Tools shipped
0
Custom servers
0%
Zod-validated inputs
0+
Client-integrated

StackTypeScript · MCP SDK · Zod · Node.js · Make.com API

Same shape, different targets

Both servers register a tool the same way: a name, a Zod schema and an async handler. Make.com uses server.registerTool(), Second Brain the SDK's shorter server.tool(). The target changes from a REST API to on-disk Markdown, but the contract every MCP client sees stays identical.

Make.com MCP

19 tools · 5 groups

A TypeScript bridge into Make.com's REST API — scenarios, blueprints, executions, data, orgs & teams. n8n is my primary automation runtime now, but the server stays maintained so Claude keeps a typed handle on the Make workspace.

Target
Make.com REST API
Tools
19 across 5 groups
Registers with
server.registerTool()
Transport
stdio · JSON-RPC 2.0
Validation
Zod schema per tool

github.com/bagodfope/make-mcp-server

make-mcp-server/src/tools/scenarios.tslines 8–43
server.registerTool(
  "make_list_scenarios",
  {
    title: "List Make Scenarios",
    description: `List all scenarios in the Make.com team.

Args:
- folder_id (number, optional): Filter scenarios by folder ID

Returns: Array of scenario objects with id, name, isActive, scheduling info.`,
    inputSchema: {
      folder_id: z.number().optional().describe("Filter by folder ID"),
    },
    annotations: {
      readOnlyHint: true,
      destructiveHint: false,
      idempotentHint: true,
      openWorldHint: true,
    },
  },
  async ({ folder_id }) => {
    try {
      let path = `/scenarios?teamId=${TEAM_ID}`;
      if (folder_id !== undefined) path += `&folderId=${folder_id}`;
      const result = await makeApiRequest<unknown>(path);
      return {
        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
      };
    } catch (error) {
      return {
        isError: true,
        content: [{ type: "text" as const, text: handleApiError(error) }],
      };
    }
  }
);

Second Brain MCP

9 tools · Obsidian vault

A custom server over my Obsidian vault. Nine tools — search, recall, read, write, update, query, context, link, skill — let Claude read and write across 360+ atomic notes, keeping the knowledge base alive between sessions.

Target
Obsidian vault · on-disk Markdown
Tools
9
Registers with
server.tool()
Transport
stdio · JSON-RPC 2.0
Resources
one context per project

~/Documents/second-brain/.mcp-server/

second-brain/.mcp-server/src/index.tslines 257–272
server.tool(
  'vault_query',
  'Strukturierte Abfrage per Frontmatter-Felder.',
  {
    type: z.string().optional().describe('Note-Type (decision, learning, etc.)'),
    project: z.string().optional().describe('Projektname'),
    status: z.string().optional().describe('Status (active, archived, draft)'),
    tags: z.array(z.string()).optional().describe('Tags (mind. einer muss matchen)'),
    since: z.string().optional().describe('Nur Notes seit Datum (YYYY-MM-DD)'),
  },
  async ({ type, project, status, tags, since }) => {
    const results = queryNotes(VAULT_PATH, { type, project, status, tags, since });
    const summary = results.map(n => ({ path: n.path, title: n.title, frontmatter: n.frontmatter }));
    return { content: [{ type: 'text' as const, text: JSON.stringify({ results: summary }, null, 2) }] };
  }
);

How these servers are built

  • Make.com + Second Brain

    MCP SDK over a custom protocol

    A standard protocol means any agent can use the server, not just Claude Code. The SDK handles transport and serialization, so I only write business logic.

  • Make.com + Second Brain

    Zod for runtime validation

    TypeScript types help while I write the code; Zod catches bad inputs at runtime before they hit the API. Both come from the same schema, so they never drift apart.

  • Make.com

    Tool groups over a flat list

    Past a handful of tools, a flat list gets unusable. On Make the 19 tools group by API domain — Scenarios, Blueprints, Executions, Data, Orgs & Teams — which keeps the surface easy to scan.

  • Make.com + Second Brain

    Build only what no server covers

    Make.com and my Obsidian vault had no usable MCP option, so I built them. Asana, Linear, Notion, and Figma already have servers I just wire in.

  • Make.com + Second Brain

    Tool descriptions are part of the contract

    The .describe() on each Zod field is what the model reads to decide when to call a tool. A vague one makes the agent guess, so I write them as carefully as the schemas.

  • Make.com

    Structured errors over thrown exceptions

    When the API rate-limits or rejects a call, the handler catches it and returns an MCP result flagged isError with a plain message, so the agent can back off or escalate instead of choking on a raw stack trace.

  • Second Brain

    Resources and tools, not just tools

    MCP splits read-only resources from action-taking tools. The Second Brain server exposes each project's context as a resource and keeps writes as tools, which makes browsing cheap and side effects explicit.

  • Make.com + Second Brain

    One server per domain

    The Make server speaks Make; the vault server speaks the vault. One monolithic “all my tools” server would let a single bug take everything down and bloat the surface Claude has to reason over.