16 Tools. 6 Resources. 10 Prompts. Here's How I Built My First MCP From Scratch.

16 Tools. 6 Resources. 10 Prompts. Here's How I Built My First MCP From Scratch.

Published: February 5, 2026 - 18 min read

For three posts, I have been teaching you the theory.

In Part 1, I explained what MCPs are and why they made me cry. In Part 2, I broke down the three superpowers: Tools, Resources, and Prompts. In Part 3, I connected everything to my prediction about AI becoming a human-to-human bridge.

Now it is time for the practice.

Meet Alex Bennett, my LinkedIn content strategist. He started as a subagent in my AI team. Then, in December 2025, I turned him into an MCP.

16 tools. 6 resources. 10 prompts. 5 design templates.

This is the complete behind-the-scenes breakdown of how I built it, why I made the decisions I made, and what I learned along the way.

The Big Picture: What Alex Bennett MCP Actually Does

Before I dive into the technical details, let me show you what this MCP enables.

The problem it solves: Creating professional LinkedIn content is time-consuming. Writing posts, designing carousels, tracking analytics, and staying consistent requires hours of work. Most people either give up or produce generic content that does not stand out.

The solution: An MCP that transforms Claude into a LinkedIn content strategist. Not just advice. Actual outputs. Real carousel PDFs. Real post formatting. Real analytics tracking.

What makes it special:

• Ask for a carousel, get a PDF file ready to upload
• Ask for a post, get LinkedIn-formatted text with proper bold/italic
• Ask for strategy advice, get recommendations backed by curated research
• Track your posts and see what is working over time

This is not a template pack or a course. It is a system that lives inside your AI.

The Architecture: How It All Fits Together

Here is how the alex-bennett-mcp is structured:

alex-bennett-mcp/
├── src/
│   ├── index.js              # Main MCP server
│   ├── tools/                # 16 tool implementations
│   ├── prompts/              # 10 prompt templates
│   ├── resources/            # 6 research resources
│   ├── research/             # Markdown research files
│   ├── templates/            # 5 HTML design templates
│   └── utils/                # Helper modules
├── package.json
└── README.md

The technology stack:

• Language: JavaScript/Node.js (TypeScript-compatible)
• Transport: STDIO (runs locally on your machine)
• Image generation: Puppeteer (renders HTML to PNG)
• PDF creation: pdf-lib (combines slides into carousels)
• Configuration: Multi-tier persistent storage

Now let me walk you through every component.

The 16 Tools: What Alex Bennett Can DO

Remember from Part 2: Tools are actions. They have side effects. They change state. They do things.

I organized Alex Bennett's 16 tools into five categories:

Category 1: Content Creation (5 tools)

These are the tools that produce actual content.

Why these tools matter: The create_carousel tool alone saves me hours. I describe what I want, and the AI generates actual PNG images for each slide, then combines them into a PDF I can upload directly to LinkedIn. No Canva. No design skills required.

Category 2: Research and Strategy (2 tools)

These tools help the AI give research-backed recommendations.

The design decision: I debated whether get_research should be a tool or just always-on context. I chose tool because loading all research into every conversation would waste tokens. Now Claude fetches relevant research only when needed.

Category 3: Analytics and Tracking (3 tools)

These tools help you understand what is working.

Why I built this: LinkedIn's native analytics are limited. I wanted to track my content performance over time and see patterns. Now I can ask Claude, "Show me my best-performing posts from last month" and get actual data.

Category 4: Workflow and Configuration (5 tools)

These tools set up and customize your environment.

The key insight: set_content_path is persistent. You set it once, and it remembers across Claude Desktop sessions. This means you do not have to reconfigure Alex Bennett every time you use him.

Category 5: Content Management (1 tool)

Why only one tool here: I kept content management simple intentionally. The file system itself handles most management. Saved drafts are just JSON files you can browse, edit, or delete.

The 6 Resources: What Alex Bennett KNOWS

Remember from Part 2: Resources are read-only knowledge. They provide context without taking action.

I curated 6 research resources covering different LinkedIn strategies:

Why I separated these: Different people use LinkedIn differently. A job seeker needs different advice than a recruiter. By separating resources, Claude can load only the relevant research for your situation.

How I built them: These are not just summaries of blog posts. I synthesized research from multiple sources, organized it by use case, and wrote it in a format that AI can easily apply. Each resource is 2,000-5,000 words of curated, actionable knowledge.

The token savings: If I loaded all 6 resources into every conversation, that would be 15,000-30,000 tokens of context. Instead, Claude fetches specific resources only when relevant. In a typical conversation, I use maybe 3,000-5,000 tokens of research. That is an 80% reduction.

The 10 Prompts: How Alex Bennett GUIDES You

Remember from Part 2: Prompts are workflow templates. They orchestrate tools and resources into one-click experiences.

I designed 10 workflow prompts covering common content creation scenarios:

Content Creation Prompts

Optimization Prompts

Strategy Prompts

How prompts work internally:

When you select the viral-post prompt in Claude Desktop, here is what happens behind the scenes:

1. The prompt loads instructions telling Claude exactly what to do
2. Claude automatically calls get_research to fetch algorithm insights
3. Claude applies the research to craft a post with a strong hook
4. Claude uses format_unicode to apply proper bold/italic formatting
5. You get a polished post ready to copy and paste to LinkedIn

All you did was select "viral-post" and provide a topic. The prompt orchestrated everything else.

The 5 Design Templates: Making Visuals Professional

One of the most valuable features of Alex Bennett MCP is actual image generation. Not descriptions. Not Canva links. Real PNG and PDF files.

I created 5 professional design templates:

And 5 dimension presets optimized for LinkedIn:

The Image Generation Pipeline: How It Actually Works

This is the part that most impressed me when I built it. Let me show you the pipeline:

User Request ("Create a 5-slide carousel about productivity")
    │
    ▼
Tool Handler (create_carousel)
    │
    ▼
Template Engine
    ├── Select design style (neobrutalism, glassmorphism, etc.)
    ├── Choose dimensions (1080x1350 for carousel)
    ├── Inject brand colors from configuration
    └── Generate HTML for each slide
    │
    ▼
Image Generator (Puppeteer)
    ├── Launch headless browser (or reuse existing instance)
    ├── Load HTML into browser page
    ├── Wait for fonts to load
    └── Screenshot to PNG (2x pixel density for retina)
    │
    ▼
PDF Generator (pdf-lib)
    ├── Load all slide images
    ├── Create PDF document
    └── Add each slide as a page
    │
    ▼
File System
    └── Save to {content_path}/carousels/

The key technical decisions:

1. HTML + CSS for templates: I could have used a design tool's API (like Canva). But HTML gives me complete control over every pixel, and it is free.

2. Puppeteer for rendering: Puppeteer is a headless Chrome browser. It renders HTML exactly like a real browser would, including fonts, gradients, and shadows.

3. Singleton browser pattern: Launching a browser takes 2-3 seconds. I reuse the same browser instance across multiple renders. First carousel: 8 seconds. Subsequent carousels: 3 seconds.

4. 2x pixel density: I render at double resolution for crisp images on retina displays. A 1080x1350 carousel is actually rendered at 2160x2700 internally.

5. pdf-lib for PDF creation: Native JavaScript PDF generation. No external services. No API costs. The PDF is created locally on your machine.

The Configuration System: Making It Persistent

One of my frustrations with AI tools is having to re-explain my preferences every session. I solved this with a multi-tier configuration system:

┌─────────────────────────────────────┐
│   Environment Variables (Layer 4)   │  Highest Priority
│   ALEX_BRAND_PRIMARY=#6366f1        │
└─────────────────────────────────────┘
              │
              ▼
┌─────────────────────────────────────┐
│   User Config (Layer 3)             │
│   {content_path}/config.json        │
└─────────────────────────────────────┘
              │
              ▼
┌─────────────────────────────────────┐
│   Global Config (Layer 2)           │
│   ~/.alex-bennett/global-config.json│
└─────────────────────────────────────┘
              │
              ▼
┌─────────────────────────────────────┐
│   Hardcoded Defaults (Layer 1)      │  Lowest Priority
└─────────────────────────────────────┘

Why this architecture?

Scenario 1: Personal creator

• Set content path once: set_content_path("~/LinkedIn")
• Configure brand colors once: set_brand({ primary: "#ff6b6b" })
• Never configure again. It just works.

Scenario 2: Agency managing multiple clients

• Global config points to ~/ClientProjects/
• Each client folder has its own config.json with their brand colors
• Switch clients by changing set_content_path("~/ClientProjects/ClientB")
• Automatically loads ClientB's brand colors

Scenario 3: Testing

• Override everything with environment variables
• No config files needed
• Each test run is isolated

The Lessons I Learned

Building Alex Bennett MCP taught me things I could not have learned from tutorials.

Lesson 1: Start Specialized, Not General

My first instinct was to build a "social media MCP" that worked with LinkedIn, Twitter, Instagram, and TikTok. That would have been a mistake.

Why specialization wins:

• Each platform has different algorithm rules
• Each platform has different content formats
• Each platform has different audience expectations
• Trying to do everything means doing nothing well

By focusing only on LinkedIn, I could curate research specifically about LinkedIn's algorithm, design templates specifically for LinkedIn's dimensions, and create prompts specifically for LinkedIn's content patterns.

The result: Alex Bennett is not a generic tool. He is a LinkedIn expert.

Lesson 2: Resources Create Real Differentiation

Claude is smart. It knows a lot about LinkedIn. But it does not know:

• The latest algorithm changes (its training data is months old)
• The specific tactics that work right now
• The nuances I have learned from my own experience

Resources fill that gap.

The 6 research resources I curated are not just summaries of public information. They are synthesized, organized, and contextualized for Claude to apply effectively. That curation is the value.

Lesson 3: Prompts Are the User Experience

I could have built Alex Bennett with just tools and resources. But that would require users to know how to orchestrate them.

Without prompts: "First use set_goal to configure your objective, then use get_research to find relevant algorithm insights, then use create_text_post with the story template, then use format_unicode to apply proper formatting..."

With prompts: Select "viral-post" from the menu. Done.

Prompts turn technical capabilities into usable workflows. They are what make MCPs accessible to people who are not developers.

Lesson 4: Persistent State Changes Everything

The configuration system was the last feature I added, but it should have been first.

Before persistence: Every Claude Desktop session started with "First, let me set my content path to ~/LinkedIn and configure my brand colors to..."

After persistence: I just start working. Alex Bennett already knows my preferences.

This seems small, but it completely changes the user experience. The MCP feels like a collaborator who knows you, not a tool you have to reconfigure every time.

Lesson 5: Error Handling Is User Experience

When things go wrong (and they will), how you handle errors determines whether users give up or keep going.

Every tool in Alex Bennett returns a consistent JSON structure:

// Success
{ success: true, carousel_path: "/path/to/file.pdf", slides_count: 5 }

// Failure
{ success: false, error: "Font not found", suggestion: "Try using a web-safe font" }

The suggestion field is key. It tells Claude how to help the user fix the problem. Claude can read the error, understand it, and propose a solution.

Lesson 6: Context Window Optimization Is Not Optional

I designed Alex Bennett with on-demand resource loading from the start. It would have been easier to dump all research into every conversation. But that would be wasteful.

The problem I avoided: 30,000 tokens of research context would mean less room for actual conversation.

The solution I chose: On-demand loading. Resources are listed (small descriptions), but content is fetched only when Claude calls get_research with a specific query.

The result: 80% token savings. Longer, more productive conversations.

What Alex Bennett MCP Looks Like in Action

Let me show you a real workflow.

Me: "Create a 5-slide carousel about why authenticity beats perfection on LinkedIn."

Claude (using Alex Bennett MCP):

1. Calls get_research with query "authenticity LinkedIn"
2. Finds relevant insights about vulnerable content outperforming polished content
3. Calls create_carousel with:
   • Topic: "Authenticity vs Perfection"
   • 5 slides with hook, content, and CTA
   • Style: neobrutalism (my default)
   • Brand colors: from my saved configuration
4. Puppeteer renders 5 HTML slides to PNG images
5. pdf-lib combines them into a single PDF
6. Returns: "Created carousel at ~/LinkedIn/carousels/2026-02-05-authenticity-beats-perfection.pdf"

Total time: About 30 seconds.

What I would have done manually: Open Canva, find a template, customize 5 slides, download as PDF, move to the right folder, rename appropriately. Minimum 20 minutes.

The Numbers: Alex Bennett MCP by the Stats

Technical specs:

• Lines of code: ~5,000 (including templates)
• Dependencies: 8 main packages (puppeteer, pdf-lib, fs-extra, etc.)
• File size: ~2MB (excluding node_modules)

Capabilities:

• 16 tools across 5 categories
• 6 research resources (~20,000 words of curated content)
• 10 workflow prompts
• 5 design templates
• 5 dimension presets

Performance:

• First carousel generation: ~8 seconds (cold start)
• Subsequent carousels: ~3 seconds (browser reused)
• Text post formatting: <1 second
• Research search: <100ms

The Human-to-Human Bridge in Practice

Remember my prediction from January?

"The people who already have status, the thought leaders, domain experts, and successful entrepreneurs, will learn to package their knowledge and insights into MCPs."

Alex Bennett is proof of concept.

I took my LinkedIn content strategy, my research, my design preferences, and my workflows and packaged them into an MCP. Now anyone with Claude Desktop can access my approach to LinkedIn content creation.

The AI is the bridge. It connects my methodology to your specific situation. It adapts my approach to your goals, your brand, your voice.

That is the human-to-human connection I predicted. And Alex Bennett is just the beginning.

Want Alex Bennett for Yourself?

I built Alex Bennett MCP for myself, but it does not have to stay that way.

If you are serious about LinkedIn content creation and want the same system I use, I would love to talk.

What you would get:

• The complete Alex Bennett MCP (16 tools, 6 resources, 10 prompts)
• Setup assistance for your Claude Desktop
• Customization for your brand colors and preferences
• All 5 professional design templates

Or if you want something custom:

• An MCP built specifically for your workflow
• Your methodology, your knowledge, your prompts
• The same architecture, adapted to your needs

Reach out to discuss Alex Bennett MCP

What This Series Accomplished

Over four posts, we covered a lot of ground:

• Part 1: What MCPs are, the N x M problem, hosts/clients/servers architecture
• Part 2: The three primitives (Tools, Resources, Prompts) with real examples
• Part 3: How MCPs enable the human-to-human bridge
• Part 4 (this post): A complete case study of a production MCP

My goal was never to make you a developer. My goal was to help you understand MCPs well enough to see their potential. To imagine what an MCP of your expertise could look like. To see the human-to-human bridge being built.

If I accomplished that, this series was worth writing.

Series Navigation

• Part 1: What MCPs are and why they matter
• Part 2: The three superpowers (Tools, Resources, Prompts)
• Part 3: How MCPs make my Human-to-Human Bridge prediction possible
• Part 4 (this post): Behind the scenes of Alex Bennett MCP (deep case study)

As always, thanks for reading!