AI Model → MCP Host → MCP Client → [transport] → MCP Server → External Tools/Data

mkdir my-mcp-server
cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// Bikin instance MCP server
const server = new McpServer({
  name: "hello-world-mcp",
  version: "1.0.0",
});

// Definisi tool pertama: greeting
server.tool(
  "greet",
  "Kasih salam ke user dengan nama tertentu",
  {
    name: z.string().describe("Nama orang yang mau disapa"),
  },
  async ({ name }) => {
    return {
      content: [
        {
          type: "text",
          text: `Halo, ${name}! Selamat datang di MCP server gue! 🚀`,
        },
      ],
    };
  }
);

// Definisi tool kedua: kalkulator sederhana
server.tool(
  "calculate",
  "Hitung operasi matematika sederhana",
  {
    a: z.number().describe("Angka pertama"),
    b: z.number().describe("Angka kedua"),
    operation: z.enum(["add", "subtract", "multiply", "divide"]).describe("Operasi yang dilakukan"),
  },
  async ({ a, b, operation }) => {
    let result;
    switch (operation) {
      case "add":
        result = a + b;
        break;
      case "subtract":
        result = a - b;
        break;
      case "multiply":
        result = a * b;
        break;
      case "divide":
        result = b !== 0 ? a / b : "Error: Division by zero";
        break;
    }
    return {
      content: [
        {
          type: "text",
          text: `Hasil ${operation} dari ${a} dan ${b} = ${result}`,
        },
      ],
    };
  }
);

// Jalankan server
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("MCP Server running on stdio");
}

main().catch(console.error);

{
  "name": "my-mcp-server",
  "version": "1.0.0",
  "type": "module",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.0.0",
    "zod": "^3.22.0"
  }
}

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import fs from "fs/promises";
import path from "path";

const server = new McpServer({
  name: "filesystem-mcp",
  version: "1.0.0",
});

// Base directory buat keamanan
const BASE_DIR = process.env.BASE_DIR || "/tmp/mcp-fs";

// Tool: Baca file
server.tool(
  "read_file",
  "Baca isi dari sebuah file",
  {
    path: z.string().describe("Path relatif ke file yang mau dibaca"),
  },
  async ({ path: filePath }) => {
    try {
      const fullPath = path.join(BASE_DIR, filePath);
      // Security check
      if (!fullPath.startsWith(BASE_DIR)) {
        throw new Error("Access denied: path traversal detected");
      }
      const content = await fs.readFile(fullPath, "utf-8");
      return {
        content: [{ type: "text", text: content }],
      };
    } catch (error) {
      return {
        content: [{ type: "text", text: `Error: ${error.message}` }],
        isError: true,
      };
    }
  }
);

// Tool: Tulis file
server.tool(
  "write_file",
  "Tulis konten ke sebuah file",
  {
    path: z.string().describe("Path relatif ke file tujuan"),
    content: z.string().describe("Konten yang mau ditulis"),
  },
  async ({ path: filePath, content }) => {
    try {
      const fullPath = path.join(BASE_DIR, filePath);
      if (!fullPath.startsWith(BASE_DIR)) {
        throw new Error("Access denied: path traversal detected");
      }
      // Bikin directory kalau belum ada
      await fs.mkdir(path.dirname(fullPath), { recursive: true });
      await fs.writeFile(fullPath, content, "utf-8");
      return {
        content: [{ type: "text", text: `File berhasil ditulis: ${filePath}` }],
      };
    } catch (error) {
      return {
        content: [{ type: "text", text: `Error: ${error.message}` }],
        isError: true,
      };
    }
  }
);

// Tool: List directory
server.tool(
  "list_directory",
  "Lihat isi dari sebuah directory",
  {
    path: z.string().optional().describe("Path directory (default: root)").default("."),
  },
  async ({ path: dirPath }) => {
    try {
      const fullPath = path.join(BASE_DIR, dirPath);
      if (!fullPath.startsWith(BASE_DIR)) {
        throw new Error("Access denied: path traversal detected");
      }
      const entries = await fs.readdir(fullPath, { withFileTypes: true });
      const listing = entries.map((entry) => {
        const type = entry.isDirectory() ? "📁" : "📄";
        return `${type} ${entry.name}`;
      });
      return {
        content: [{ type: "text", text: listing.join("\n") }],
      };
    } catch (error) {
      return {
        content: [{ type: "text", text: `Error: ${error.message}` }],
        isError: true,
      };
    }
  }
);

// Resource: Expose file sebagai resource
server.resource(
  "file://{path}",
  "Baca konten file dari path tertentu",
  async (uri) => {
    try {
      const filePath = uri.href.replace("file://", "");
      const fullPath = path.join(BASE_DIR, filePath);
      if (!fullPath.startsWith(BASE_DIR)) {
        throw new Error("Access denied");
      }
      const content = await fs.readFile(fullPath, "utf-8");
      return {
        contents: [
          {
            uri: uri.href,
            mimeType: "text/plain",
            text: content,
          },
        ],
      };
    } catch (error) {
      throw new Error(`Failed to read resource: ${error.message}`);
    }
  }
);

async function main() {
  await fs.mkdir(BASE_DIR, { recursive: true });
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error(`Filesystem MCP Server running (base: ${BASE_DIR})`);
}

main().catch(console.error);

{
  "mcpServers": {
    "hello-world": {
      "command": "node",
      "args": ["/path/to/my-mcp-server/index.js"],
      "env": {}
    },
    "filesystem": {
      "command": "node",
      "args": ["/path/to/filesystem-mcp/index.js"],
      "env": {
        "BASE_DIR": "/Users/yourname/Documents/mcp-data"
      }
    }
  }
}

pip install mcp

import asyncio
import json
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp import types

# Bikin server instance
server = Server("python-mcp-demo")

@server.list_tools()
async def list_tools():
    return [
        types.Tool(
            name="analyze_text",
            description="Analisis teks: hitung kata, karakter, dan kalimat",
            inputSchema={
                "type": "object",
                "properties": {
                    "text": {
                        "type": "string",
                        "description": "Teks yang mau dianalisis"
                    }
                },
                "required": ["text"]
            }
        ),
        types.Tool(
            name="generate_password",
            description="Generate random password",
            inputSchema={
                "type": "object",
                "properties": {
                    "length": {
                        "type": "integer",
                        "description": "Panjang password",
                        "default": 16
                    }
                }
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "analyze_text":
        text = arguments["text"]
        words = len(text.split())
        chars = len(text)
        sentences = text.count('.') + text.count('!') + text.count('?')
        
        result = {
            "word_count": words,
            "char_count": chars,
            "sentence_count": sentences,
            "avg_word_length": round(sum(len(w) for w in text.split()) / words, 2) if words > 0 else 0
        }
        return [types.TextContent(type="text", text=json.dumps(result, indent=2))]
    
    elif name == "generate_password":
        import string
        import secrets
        length = arguments.get("length", 16)
        chars = string.ascii_letters + string.digits + "!@#$%^&*"
        password = ''.join(secrets.choice(chars) for _ in range(length))
        return [types.TextContent(type="text", text=f"Generated password: {password}")]

async def main():
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, server.create_initialization_options())

if __name__ == "__main__":
    asyncio.run(main())

FROM node:20-slim

WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY . .

CMD ["node", "index.js"]

import express from "express";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";

const app = express();
const server = new McpServer({
  name: "remote-mcp",
  version: "1.0.0",
});

// ... daftarin tools lo di sini ...

const sessions = new Map();

app.get("/sse", async (req, res) => {
  const transport = new SSEServerTransport("/messages", res);
  sessions.set(transport.sessionId, transport);
  
  transport.onclose = () => {
    sessions.delete(transport.sessionId);
  };
  
  await server.connect(transport);
});

app.post("/messages", async (req, res) => {
  const sessionId = req.query.sessionId;
  const transport = sessions.get(sessionId);
  if (transport) {
    await transport.handlePostMessage(req, res);
  } else {
    res.status(404).json({ error: "Session not found" });
  }
});

app.listen(3001, () => {
  console.log("MCP SSE Server running on port 3001");
});

server.tool("risky_tool", "Tool yang bisa error", {}, async () => {
  try {
    // ... logic
    return { content: [{ type: "text", text: "Success!" }] };
  } catch (error) {
    return {
      content: [{ type: "text", text: `Gagal: ${error.message}` }],
      isError: true,
    };
  }
});