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.
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
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.
- Claude Codethe client
- MCPJSON-RPC over stdio
- ServerTypeScript + Zod
- 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-onlyFinds the notes a task needs, semantic and keyword search combined.
taskstring · requiredThe task in plain language
"writing tool descriptions"projectstring · optionalOnly notes of this project
not sentlimitnumber · default 5Max results
3
{
"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
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/
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
isErrorwith 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.