🔌 Resources

Resources represent data or content that AI models can access. These can be:

• Files and documents
• Database records
• API responses
• Web pages
• Real-time data streams

// Example resource
{
  "uri": "file:///docs/guide.md",
  "name": "User Guide",
  "mimeType": "text/markdown",
  "description": "Product user guide"
}

🛠️ Tools

Tools are functions that AI models can invoke to perform actions:

• Query databases
• Call APIs
• Execute code
• Modify files
• Send notifications

// Example tool definition
{
  "name": "search_database",
  "description": "Search the product database",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" },
      "limit": { "type": "number" }
    }
  }
}

💬 Prompts

Prompts are reusable templates that provide context and structure:

• Pre-configured conversation starters
• System prompts with embedded context
• Workflow templates
• Role definitions

Layer Model

1. Requests

Client initiates an action and expects a response:

{
  "jsonrpc": "2.0",
  "id": "1",
  "method": "tools/call",
  "params": {
    "name": "search_database",
    "arguments": {
      "query": "artificial intelligence",
      "limit": 10
    }
  }
}

2. Responses

Server sends back the result:

{
  "jsonrpc": "2.0",
  "id": "1",
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Found 10 results..."
      }
    ]
  }
}

3. Notifications

One-way messages that don't expect responses:

{
  "jsonrpc": "2.0",
  "method": "notifications/progress",
  "params": {
    "progressToken": "abc123",
    "progress": 50,
    "total": 100
  }
}

Step 1: List Available Tools

// Request
{
  "jsonrpc": "2.0",
  "id": "1",
  "method": "tools/list"
}

// Response
{
  "jsonrpc": "2.0",
  "id": "1",
  "result": {
    "tools": [
      {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "inputSchema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "City name"
            }
          },
          "required": ["location"]
        }
      }
    ]
  }
}

Step 2: Call the Tool

// Request
{
  "jsonrpc": "2.0",
  "id": "2",
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": {
      "location": "San Francisco"
    }
  }
}

// Response
{
  "jsonrpc": "2.0",
  "id": "2",
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Weather in San Francisco: 18°C, Partly Cloudy"
      }
    ]
  }
}

What is an MCP Server?

An MCP server is a program that exposes resources, tools, and prompts to AI applications. Servers can be written in any language that supports JSON-RPC.

Server Responsibilities:

• Implement the MCP protocol (JSON-RPC handlers)
• Define and expose resources, tools, and prompts
• Handle authentication and authorization
• Manage connections to underlying data sources
• Validate inputs and sanitize outputs

Example: Simple MCP Server (TypeScript)

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({
  name: "example-server",
  version: "1.0.0"
}, {
  capabilities: {
    tools: {}
  }
});

// Define a tool
server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "echo",
    description: "Echoes back the input",
    inputSchema: {
      type: "object",
      properties: {
        message: { type: "string" }
      }
    }
  }]
}));

// Handle tool calls
server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "echo") {
    return {
      content: [{
        type: "text",
        text: request.params.arguments.message
      }]
    };
  }
});

// Start server
const transport = new StdioServerTransport();
await server.connect(transport);

What is an MCP Client?

An MCP client is embedded in AI applications (like Claude Desktop, IDEs) and manages connections to MCP servers. Most developers won't need to build clients from scratch.

Client Responsibilities:

• Discover and connect to MCP servers
• Send requests on behalf of the LLM
• Handle responses and errors
• Manage multiple server connections
• Provide context to the LLM

Resource Types

Resources represent any data or content the AI can access:

{
  "uri": "file:///home/user/document.pdf",
  "name": "Project Plan",
  "mimeType": "application/pdf"
}

{
  "uri": "database://users/12345",
  "name": "User Profile",
  "mimeType": "application/json"
}

{
  "uri": "https://example.com/api/data",
  "name": "API Data",
  "mimeType": "application/json"
}

Tool Schema

Tools must be defined with a JSON Schema for their inputs:

{
  "name": "create_file",
  "description": "Creates a new file with content",
  "inputSchema": {
    "type": "object",
    "properties": {
      "path": {
        "type": "string",
        "description": "File path"
      },
      "content": {
        "type": "string",
        "description": "File content"
      },
      "overwrite": {
        "type": "boolean",
        "description": "Overwrite if exists",
        "default": false
      }
    },
    "required": ["path", "content"]
  }
}

Prompt Templates

Prompts provide reusable conversation templates:

{
  "name": "code_review",
  "description": "Review code for issues",
  "arguments": [
    {
      "name": "language",
      "description": "Programming language",
      "required": true
    },
    {
      "name": "code",
      "description": "Code to review",
      "required": true
    }
  ]
}

// When called, generates:
{
  "messages": [
    {
      "role": "user",
      "content": {
        "type": "text",
        "text": "Review this {{language}} code for issues:\n\n{{code}}"
      }
    }
  ]
}

🔷 Anthropic SDKs

There are TWO separate but complementary official SDKs for building agents with Claude and MCP:

1. Anthropic Claude SDK (@anthropic-ai/sdk)

Official SDK for the Claude API - handles LLM interactions, messaging, and tool use.

• Claude API integration
• TypeScript and Python support
• Tool use (function calling)
• Streaming responses
• Multi-turn conversations

npm install @anthropic-ai/sdk

2. MCP SDK (@modelcontextprotocol/sdk)

Official SDK for the Model Context Protocol - handles MCP server/client implementation.

• Build MCP servers and clients
• Expose tools, resources, and prompts
• JSON-RPC protocol handling
• Transport layer (stdio, HTTP+SSE)

npm install @modelcontextprotocol/sdk

How they work together: Use @anthropic-ai/sdk to interact with Claude, and @modelcontextprotocol/sdk to build MCP servers that expose tools Claude can use.

🦜 LangChain

Popular framework for building LLM applications with extensive tool ecosystem.

• Chain multiple operations together
• Large ecosystem of integrations
• Memory management
• Can integrate with MCP servers

from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub

# Get the prompt template
prompt = hub.pull("hwchase17/react")

# Create the agent
agent = create_react_agent(llm, tools, prompt)

# Create agent executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

🧠 AutoGen

Microsoft's framework for building multi-agent systems.

• Multiple agents that can communicate
• Built-in conversation patterns
• Code execution capabilities
• Human-in-the-loop support

🌊 CrewAI

Framework for orchestrating role-playing AI agents.

• Role-based agent definition
• Task delegation
• Process orchestration
• Built-in tools and integrations

import Anthropic from "@anthropic-ai/sdk";
import { MCPClient } from "@modelcontextprotocol/sdk/client/index.js";

// Connect to MCP server
const mcpClient = new MCPClient();
await mcpClient.connect(/* ... */);

// Get available tools
const { tools } = await mcpClient.request("tools/list");

// Create Claude client
const anthropic = new Anthropic();

// Agent loop
async function runAgent(userMessage) {
  let messages = [{ role: "user", content: userMessage }];

  while (true) {
    // Ask Claude what to do
    const response = await anthropic.messages.create({
      model: "claude-3-5-sonnet-20241022",
      messages,
      tools, // Pass MCP tools
      max_tokens: 4096
    });

    // Check if Claude wants to use a tool
    const toolUse = response.content.find(
      block => block.type === "tool_use"
    );

    if (!toolUse) {
      // No more tools needed, return response
      return response.content[0].text;
    }

    // Call the tool via MCP
    const toolResult = await mcpClient.request("tools/call", {
      name: toolUse.name,
      arguments: toolUse.input
    });

    // Add tool result to conversation
    messages.push({
      role: "assistant",
      content: response.content
    });
    messages.push({
      role: "user",
      content: [{
        type: "tool_result",
        tool_use_id: toolUse.id,
        content: toolResult.content
      }]
    });

    // Loop continues...
  }
}

// Use the agent
const result = await runAgent(
  "Search for recent AI papers and summarize the top 3"
);

Prerequisites

• Node.js 18+ or Python 3.10+
• Basic understanding of JSON and APIs
• Familiarity with async/await programming

Installation

# TypeScript/JavaScript
npm install @modelcontextprotocol/sdk

# Python
pip install mcp

Step 1: Server Setup

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import fs from "fs/promises";
import path from "path";

const server = new Server({
  name: "filesystem-server",
  version: "1.0.0"
}, {
  capabilities: {
    resources: {},
    tools: {}
  }
});

const ALLOWED_DIR = process.env.ALLOWED_DIR || process.cwd();

Step 2: Implement Resources

// List available files as resources
server.setRequestHandler("resources/list", async () => {
  const files = await fs.readdir(ALLOWED_DIR);

  return {
    resources: files.map(file => ({
      uri: `file:///${path.join(ALLOWED_DIR, file)}`,
      name: file,
      mimeType: getMimeType(file),
      description: `File: ${file}`
    }))
  };
});

// Read file content
server.setRequestHandler("resources/read", async (request) => {
  const filePath = request.params.uri.replace("file:///", "");

  // Security check
  if (!filePath.startsWith(ALLOWED_DIR)) {
    throw new Error("Access denied");
  }

  const content = await fs.readFile(filePath, "utf-8");

  return {
    contents: [{
      uri: request.params.uri,
      mimeType: getMimeType(filePath),
      text: content
    }]
  };
});

Step 3: Implement Tools

// Define available tools
server.setRequestHandler("tools/list", async () => ({
  tools: [
    {
      name: "read_file",
      description: "Read contents of a file",
      inputSchema: {
        type: "object",
        properties: {
          path: {
            type: "string",
            description: "Path to file"
          }
        },
        required: ["path"]
      }
    },
    {
      name: "write_file",
      description: "Write content to a file",
      inputSchema: {
        type: "object",
        properties: {
          path: { type: "string" },
          content: { type: "string" }
        },
        required: ["path", "content"]
      }
    },
    {
      name: "list_directory",
      description: "List files in a directory",
      inputSchema: {
        type: "object",
        properties: {
          path: { type: "string" }
        }
      }
    }
  ]
}));

// Handle tool calls
server.setRequestHandler("tools/call", async (request) => {
  const { name, arguments: args } = request.params;

  switch (name) {
    case "read_file": {
      const fullPath = path.join(ALLOWED_DIR, args.path);
      const content = await fs.readFile(fullPath, "utf-8");
      return {
        content: [{
          type: "text",
          text: content
        }]
      };
    }

    case "write_file": {
      const fullPath = path.join(ALLOWED_DIR, args.path);
      await fs.writeFile(fullPath, args.content);
      return {
        content: [{
          type: "text",
          text: `File written: ${args.path}`
        }]
      };
    }

    case "list_directory": {
      const dirPath = args.path
        ? path.join(ALLOWED_DIR, args.path)
        : ALLOWED_DIR;
      const files = await fs.readdir(dirPath);
      return {
        content: [{
          type: "text",
          text: files.join("\n")
        }]
      };
    }

    default:
      throw new Error(`Unknown tool: ${name}`);
  }
});

Step 4: Start the Server

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Filesystem MCP server running");
}

main().catch(console.error);

Configuration

Add your server to Claude Desktop's config file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "filesystem": {
      "command": "node",
      "args": ["/path/to/your/server/dist/index.js"],
      "env": {
        "ALLOWED_DIR": "/Users/yourname/Documents"
      }
    }
  }
}

📁 Filesystem

Access and manipulate local files and directories

npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/dir

Tools: read_file, write_file, list_directory, create_directory, move_file, search_files

🌐 Fetch

Make HTTP requests and fetch web content

npx -y @modelcontextprotocol/server-fetch

Tools: fetch_url, post_data

🗄️ PostgreSQL

Query and interact with PostgreSQL databases

npx -y @modelcontextprotocol/server-postgres postgresql://localhost/mydb

Tools: query, list_tables, describe_table

💾 SQLite

Work with SQLite databases

npx -y @modelcontextprotocol/server-sqlite /path/to/database.db

Tools: query, list_tables, read_schema

🐙 GitHub

Interact with GitHub repositories, issues, and PRs

npx -y @modelcontextprotocol/server-github

Tools: create_issue, list_repos, get_file, create_pr, search_code

🔍 MCP Inspector

Interactive debugging tool for MCP servers

npx @modelcontextprotocol/inspector <command>

Features:

• Web-based UI for testing
• View all tools, resources, and prompts
• Test tool calls interactively
• See protocol messages in real-time

📦 Create MCP Server

Scaffolding tool for new servers

npx create-mcp-server my-server

Creates a ready-to-go TypeScript project with:

• Basic server structure
• Example tools and resources
• Build configuration
• Testing setup

Use Case

An AI agent that reviews code by accessing the filesystem, running tests, and checking style guidelines.

MCP Servers Used

• Filesystem: Read source code files
• Git: Access commit history and diffs
• Shell: Run linters and tests

Workflow

1. User asks: "Review the recent changes in src/auth.ts"
2. Agent uses Git server to get the diff
3. Agent uses Filesystem to read related files for context
4. Agent uses Shell server to run TypeScript compiler and ESLint
5. Agent provides comprehensive review with specific suggestions

Use Case

An agent that searches the web, reads documents, and compiles research summaries.

MCP Servers Used

• Web Search: Find relevant articles and papers
• Fetch: Download and parse web content
• Filesystem: Save and organize research notes
• SQLite: Store citations and references

Example Interaction

User: Research the latest developments in quantum computing and create a summary

Agent Actions:
1. Uses web_search tool to find recent papers
2. Uses fetch tool to download paper abstracts
3. Uses filesystem to save source materials
4. Uses sqlite to store references with metadata
5. Generates comprehensive summary with citations
6. Uses filesystem to save final report

Use Case

An agent that monitors systems, analyzes logs, and performs automated responses.

MCP Servers Used

• Docker: Inspect containers and services
• AWS: Check cloud infrastructure status
• PostgreSQL: Query application databases
• GitHub: Create issues for problems found
• Slack: Send notifications to team

Automation Example

Trigger: High error rate detected

Agent Actions:
1. Query PostgreSQL for recent error logs
2. Check Docker for container health status
3. Analyze AWS CloudWatch metrics
4. Identify root cause (database connection timeout)
5. Create GitHub issue with full context
6. Send Slack notification to on-call engineer
7. Attempt automatic remediation (restart connection pool)

Use Case

An agent that helps manage blog content, images, and publishing workflows.

MCP Servers Used

• Filesystem: Read and write blog posts
• DALL-E: Generate featured images
• Git: Version control for content
• GitHub: Create PRs for review

Publishing Workflow

User: Create a blog post about MCP with a featured image

Agent:
1. Drafts blog post content
2. Uses filesystem to save draft markdown
3. Generates featured image with DALL-E
4. Saves image to assets folder
5. Updates post frontmatter with image path
6. Creates git branch for new post
7. Opens GitHub PR for review
8. Notifies author when ready

Use Case

An intelligent support agent that accesses documentation, tickets, and user data.

MCP Servers Used

• PostgreSQL: Access customer and ticket database
• Filesystem: Read product documentation
• Zendesk/Custom API: Update tickets
• Stripe/Custom API: Check billing info

Support Flow

Customer: Why am I being charged $99 instead of $49?

Agent:
1. Query PostgreSQL for customer account details
2. Check Stripe for current subscription and billing history
3. Read documentation about pricing plans
4. Identify issue: Customer on legacy plan, price increased
5. Search knowledge base for migration options
6. Provide explanation with options
7. Update support ticket with resolution
8. Offer to process refund if applicable

📚 Core Resources

• Model Context Protocol Official Site
• MCP Specification
• MCP GitHub Organization
• Anthropic MCP Resources

🔧 Official Example Servers

• Filesystem Server - Full-featured file access
• Fetch Server - HTTP request capabilities
• PostgreSQL Server - Database integration
• GitHub Server - GitHub API integration

🛠️ Essential Tools

• MCP Inspector: npx @modelcontextprotocol/inspector
• Server Template: npx create-mcp-server
• Claude Desktop: Download

💬 Get Help & Connect

• Anthropic Discord - #mcp channel
• GitHub Discussions
• Twitter/X - Follow for updates

🔗 Official MCP Resources

• MCP Protocol Specification: https://spec.modelcontextprotocol.io/
• MCP Documentation: https://modelcontextprotocol.io/
• MCP GitHub Organization: https://github.com/modelcontextprotocol
• MCP TypeScript SDK: https://github.com/modelcontextprotocol/typescript-sdk
• MCP Python SDK: https://github.com/modelcontextprotocol/python-sdk
• Official MCP Announcement: https://www.anthropic.com/news/model-context-protocol

🦜 LangChain

• LangChain Documentation: https://python.langchain.com/docs/introduction/
• LangChain Agents Guide: https://python.langchain.com/docs/modules/agents/
• LangChain GitHub: https://github.com/langchain-ai/langchain

🧠 AutoGen

• AutoGen Documentation: https://microsoft.github.io/autogen/
• AutoGen GitHub: https://github.com/microsoft/autogen
• AutoGen Examples: https://microsoft.github.io/autogen/docs/Examples/

🌊 CrewAI

• CrewAI Documentation: https://docs.crewai.com/
• CrewAI GitHub: https://github.com/joaomdmoura/crewAI
• CrewAI Examples: https://github.com/joaomdmoura/crewAI-examples

🤖 Anthropic Claude

• Claude API Documentation: https://docs.anthropic.com/
• Anthropic SDK (TypeScript): https://github.com/anthropics/anthropic-sdk-typescript
• Anthropic SDK (Python): https://github.com/anthropics/anthropic-sdk-python
• Claude Tool Use Guide: https://docs.anthropic.com/en/docs/tool-use

🎯 Next Steps

Now that you understand MCP and agentkits:

• ✅ Try the examples in this guide
• ✅ Build a simple server for your own use case
• ✅ Join the community and share what you build
• ✅ Contribute to open source MCP servers
• ✅ Explore multi-agent architectures