# Cara Bikin MCP Server Sendiri dari Nol: Sampai Bisa Dipakai Claude Code dan OpenClaw

- URL: https://komunitech.com/blog/tutorial/cara-bikin-mcp-server-sendiri-dari-nol/
- Diterbitkan: 2026-11-19
- Diperbarui: 2026-11-19
- Penulis: Priyo Harjiyono
- Penerbit: KomuniTech (https://komunitech.com)

---

**TL;DR:** Bikin MCP server sendiri itu satu file program kecil: daftarkan tool yang mau kamu kasih ke AI, pilih transportnya (stdio buat lokal), lalu sambungkan ke Claude Code atau OpenClaw. Tutorial ini memakai SDK resmi v2 yang berlaku per November 2026 — TypeScript lewat @modelcontextprotocol/server atau Python lewat paket mcp.



**💡 Key Takeaway**




- **Satu server, semua client bisa pakai.** Server yang kamu bangun sekali bisa dipakai Claude Code, OpenClaw, dan client MCP lain.

- **Pakai SDK v2, bukan tutorial 2025.** TypeScript: paket @modelcontextprotocol/server dengan registerTool; Python: kelas MCPServer, bukan FastMCP.

- **Spesifikasi yang berlaku: revisi 2026-07-28.** Protokolnya stateless — tidak ada lagi handshake initialize dan session id.

- **Uji dulu di Inspector sebelum disambungkan ke client.** MCP Inspector memanggil tool kamu tanpa AI, jadi kamu tahu servernya jalan sebelum Claude memakainya.

- **Paling sering bikin gagal: console.log di server stdio, path relatif, dan lupa build.**





## Kenapa repot-repot bikin MCP server sendiri?


Bayangin kamu sudah nyaman pakai Claude Code atau OpenClaw. Suatu hari kamu kepikiran: enak banget kalau agent ini bisa baca folder catatan kerjaku, atau nyimpen hasil riset ke arsipku sendiri. Masalahnya, agent itu tidak tahu folder catatanmu ada di mana.


Di sinilah MCP server bikinan sendiri masuk: satu program kecil yang memberi tahu agent apa saja kemampuan yang kamu sediakan, cara memanggilnya, dan datanya. Sekali jadi, semua client MCP bisa memakainya. Bedanya dengan server yang sudah jadi: server bikinanmu memberi kemampuan yang kamu butuhkan, ke data yang kamu punya, dengan batasan yang kamu atur sendiri.


Tutorial ini membangun satu server dari nol sampai jalan: server catatan yang bisa menyimpan, mencari, dan menampilkan daftar catatan, plus satu template prompt buat merekap semuanya.



## MCP server itu apa, singkat saja


Model Context Protocol, atau MCP, adalah standar terbuka yang mengatur cara aplikasi AI terhubung ke tools dan data di luar dirinya. Anthropic memperkenalkannya pada 25 November 2024, dan sejak 9 Desember 2025 protokol ini dikelola Agentic AI Foundation di bawah Linux Foundation. Penjelasan lengkap soal host, client, dan server sudah dibedah di [pembedahan MCP Server dan alasan AI Agent membutuhkannya](https://komunitech.com/blog/ai-agent/mcp-server-apa-itu-cara-kerja-ai-agent-2026/).


Server MCP mengekspos tiga primitif:





| **Primitif**
| **Siapa yang memutuskan**



| Tools
| Model — dia yang memilih memanggil



| Resources
| Aplikasi — data yang dimuat ke konteks



| Prompts
| User — template yang dipilih manual





Transportnya ada dua. **stdio** buat server lokal: client menjalankan servermu sebagai subprocess, dan mereka ngobrol lewat stdin/stdout. Ini yang dipakai tutorial ini. **Streamable HTTP** buat server remote, dibahas singkat di akhir. Satu hal yang wajib kamu pegang: revisi spesifikasi **2026-07-28** mengubah inti protokol jadi stateless — handshake initialize dan header session Mcp-Session-Id dihapus. Kalau tutorial yang kamu ikuti masih menulis server.connect() atau server.tool(), itu tutorial era 2025.



## Pilih SDK dulu: TypeScript atau Python?


Dua-duanya SDK resmi, dua-duanya mengimplementasikan revisi 2026-07-28. Pilih berdasarkan bahasa yang sudah kamu pakai sehari-hari.





| **Perbandingan**
| **TypeScript**
| **Python**



| Paket yang di-install
| @modelcontextprotocol/server + zod
| mcp[cli]



| Kelas server
| McpServer
| MCPServer



| Cara mendaftarkan tool
| server.registerTool(nama, config, handler)
| Dekorator @mcp.tool() di atas function biasa



| Skema input
| Zod (z.object)
| Type hints function



| Menjalankan server
| serveStdio(factory) atau npx tsx
| mcp.run() atau mcp dev server.py





Artikel ini memakai TypeScript sebagai jalur utama, karena sebagian besar pembaca yang sudah memakai Claude Code dan OpenClaw sudah punya Node ter-install. Jalur Python dibahas setelahnya. Yang penting: jangan campur tutorial v1 dan v2 — paket TypeScript lama (@modelcontextprotocol/sdk) itu jalur maintenance, dan kelas FastMCP dari Python lama sudah berganti nama jadi MCPServer di v2.



## Setup proyek: lima menit, tanpa kejutan


Cek versi Node dengan node --version — butuh 20 atau lebih baru. Tutorial ini diuji dengan Node 24.


mkdir catatan-mcp && cd catatan-mcp
npm init -y
npm pkg set type=module
npm install @modelcontextprotocol/server zod
npm install -D typescript @types/node
mkdir src
Perhatikan npm pkg set type=module: SDK v2 hanya tersedia sebagai ES module. Versi yang ter-install waktu tutorial ini diuji (19 November 2026): @modelcontextprotocol/server 2.4.0, zod 4.6.7, typescript 5.9.3. Pola kodenya tetap sama selama masih di lini v2.


Buat file tsconfig.json di root proyek dan tambahkan script build di package.json ("scripts": { "build": "tsc" }). Client menjalankan hasil build di build/index.js.


{
"compilerOptions": {
"target": "ES2022",
"module": "Node16",
"moduleResolution": "Node16",
"types": ["node"],
"outDir": "./build",
"rootDir": "./src",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true
},
"include": ["src/**/*"],
"exclude": ["node_modules"]
}

## Tulis server pertamamu: server catatan


Ini seluruh servernya, satu file src/index.ts:


#!/usr/bin/env node
import { McpServer } from "@modelcontextprotocol/server";
import { serveStdio } from "@modelcontextprotocol/server/stdio";
import * as z from "zod/v4";
import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
import { join } from "node:path";

// Folder catatan; isi lewat env CATATAN_FOLDER.
const FOLDER = process.env.CATATAN_FOLDER ?? join(process.cwd(), "catatan");

export function createServer(): McpServer {
const server = new McpServer({ name: "catatan", version: "1.0.0" });

// Tool 1: simpan satu catatan sebagai file Markdown.
server.registerTool(
"simpan-catatan",
{
description:
"Simpan satu catatan teks ke folder catatan. Pakai saat user minta mengingat atau mencatat sesuatu.",
inputSchema: z.object({
judul: z
.string()
.min(1)
.max(100)
.describe("Judul catatan, dipakai sebagai nama file tanpa spasi"),
isi: z.string().min(1).describe("Isi catatan, teks biasa atau Markdown"),
}),
},
async ({ judul, isi }) => {
const aman = judul.replace(/[^a-zA-Z0-9-_]/g, "-");
await mkdir(FOLDER, { recursive: true });
await writeFile(join(FOLDER, ${aman}.md), isi, "utf-8");
return {
content: [{ type: "text", text: Catatan tersimpan: ${aman}.md }],
};
},
);

// Tool 2: cari catatan yang mengandung kata kunci.
server.registerTool(
"cari-catatan",
{
description:
"Cari catatan yang mengandung kata kunci tertentu. Kembalikan nama file yang cocok.",
inputSchema: z.object({
kataKunci: z
.string()
.min(1)
.describe("Kata kunci yang dicari di isi catatan"),
}),
},
async ({ kataKunci }) => {
await mkdir(FOLDER, { recursive: true });
const files = (await readdir(FOLDER)).filter((f) => f.endsWith(".md"));
const cocok: string[] = [];
for (const f of files) {
const isi = await readFile(join(FOLDER, f), "utf-8");
if (isi.toLowerCase().includes(kataKunci.toLowerCase())) cocok.push(f);
}
return {
content: [
{
type: "text",
text: cocok.length
? Ditemukan di: ${cocok.join(", ")}
: "Tidak ada catatan yang cocok.",
},
],
};
},
);

// Resource: daftar semua catatan yang tersimpan.
server.registerResource(
"daftar-catatan",
"catatan://daftar",
{
title: "Daftar catatan",
description: "Daftar semua judul catatan yang tersimpan",
mimeType: "text/plain",
},
async (uri) => {
await mkdir(FOLDER, { recursive: true });
const files = (await readdir(FOLDER)).filter((f) => f.endsWith(".md"));
return {
contents: [
{
uri: uri.href,
text: files.join("n") || "Belum ada catatan.",
},
],
};
},
);

// Prompt: template rekap catatan.
server.registerPrompt(
"rekap-catatan",
{
title: "Rekap catatan",
description: "Buat rekap semua catatan yang tersimpan",
argsSchema: z.object({
fokus: z
.string()
.optional()
.describe("Topik yang mau direkap, kosongkan untuk semua topik"),
}),
},
({ fokus }) => ({
messages: [
{
role: "user" as const,
content: {
type: "text" as const,
text: fokus
? Baca semua catatan di folder catatan, lalu buat rekap singkat khusus topik: ${fokus}.
: "Baca semua catatan di folder catatan, lalu buat rekap singkat per topik.",
},
},
],
}),
);

return server;
}

void serveStdio(createServer);
console.error("Server catatan MCP jalan di stdio");
Build dan jalankan sekali buat memastikan tidak ada error ketik:


npm run build
node build/index.js
Kalau tidak ada error, terminal akan diam setelah menampilkan Server catatan MCP jalan di stdio — itu normal: server stdio menunggu client memulai percakapan. Berhentikan dengan Ctrl+C.


Tiga hal penting dari kode di atas. **Pertama, registerTool menerima tiga hal: nama, konfigurasi, dan handler.** Dari skema Zod di inputSchema, SDK menurunkan JSON Schema yang dilihat model dan memvalidasi argumen sebelum handler berjalan. Kalau model memanggil simpan-catatan tanpa field isi, SDK yang menolak.


**Kedua, deskripsi itu instruksi, bukan dokumentasi.** Model memutuskan kapan memanggil tool dari description dan teks .describe() di tiap field. Tulis seperti instruksi ke rekan kerja: apa yang dilakukan tool ini, dan kapan dipakai. Deskripsi yang kabur membuat model ragu.


**Ketiga, jangan pernah menulis ke stdout di server stdio.** Stdout adalah jalur protokolnya — satu console.log nyasar saja sudah cukup merusak aliran pesannya. Itu sebabnya banner di baris terakhir memakai console.error (stderr). Aturan yang sama berlaku buat library yang kamu pakai.


Satu detail terakhir: createServer ditulis sebagai factory, karena serveStdio bisa membangun instance baru tiap ada koneksi. State yang harus bertahan antar-koneksi — di sini folder catatan di disk — ditaruh di luar factory, di level modul.



## Versi Python-nya: server yang sama, setengah baris kode


Kalau kamu tim Python (3.10+, diuji dengan 3.12), server yang sama bisa ditulis lebih pendek, karena SDK Python membaca skema dari type hints function:


mkdir catatan-mcp-py && cd catatan-mcp-py
python3 -m venv .venv
source .venv/bin/activate
pip install "mcp[cli]"
Paket mcp versi 2.3.0 adalah yang ter-install waktu tutorial ini diuji (19 November 2026). Ini file server.py lengkapnya:


"""Server catatan MCP - Python SDK v2 (MCPServer)."""
import os
import re
from pathlib import Path

from mcp.server import MCPServer

FOLDER = Path(os.environ.get("CATATAN_FOLDER", Path.cwd() / "catatan"))
FOLDER.mkdir(parents=True, exist_ok=True)

mcp = MCPServer("catatan")


def _aman(judul: str) -> str:
return re.sub(r"[^a-zA-Z0-9-_]", "-", judul)


@mcp.tool()
def simpan_catatan(judul: str, isi: str) -> str:
"""Simpan satu catatan teks ke folder catatan sebagai file Markdown."""
nama = _aman(judul) + ".md"
(FOLDER / nama).write_text(isi, encoding="utf-8")
return f"Catatan tersimpan: {nama}"


@mcp.tool()
def cari_catatan(kata_kunci: str) -> str:
"""Cari catatan yang mengandung kata kunci tertentu."""
cocok = []
for f in sorted(FOLDER.glob("*.md")):
if kata_kunci.lower() in f.read_text(encoding="utf-8").lower():
cocok.append(f.name)
return f"Ditemukan di: {', '.join(cocok)}" if cocok else "Tidak ada catatan yang cocok."


@mcp.resource("catatan://daftar")
def daftar_catatan() -> str:
"""Daftar semua judul catatan yang tersimpan."""
return "n".join(sorted(f.name for f in FOLDER.glob("*.md"))) or "Belum ada catatan."


@mcp.prompt()
def rekap_catatan() -> str:
"""Buat rekap semua catatan yang tersimpan."""
return "Baca semua catatan di folder catatan, lalu buat rekap singkat per topik."


if __name__ == "__main__":
mcp.run()
Tiga hal yang perlu diperhatikan. **Pertama, import-nya from mcp.server import MCPServer.** Bukan from mcp import MCPServer — bentuk itu tidak ada — dan bukan from mcp.server.fastmcp import FastMCP.


**Kedua, satu dekorator per primitif.** @mcp.tool() membuat function jadi tool, @mcp.resource("catatan://daftar") jadi resource, @mcp.prompt() jadi prompt. Nama, deskripsi, dan skema dibaca SDK dari nama function, docstring, dan type hints-nya.


**Ketiga, mcp.run() tanpa argumen menjalankan server lewat stdio.** Buat HTTP: mcp run server.py --transport streamable-http. Satu perbedaan kecil: nama tool Python memakai garis bawah (simpan_catatan), bukan tanda hubung (simpan-catatan).



## Uji dulu dengan MCP Inspector, sebelum AI yang mencoba


MCP Inspector adalah client uji resmi: aplikasi web lokal yang memanggil tool servermu langsung, tanpa model AI di tengah. Inspector butuh Node 22.19 atau lebih baru. Jalankan dari root proyek TypeScript:


npx @modelcontextprotocol/inspector npx tsx src/index.ts
Perintah itu membuka tab browser. Klik **Connect**, lalu buka tab **Tools**: kamu akan melihat simpan-catatan dan cari-catatan dengan form input yang dibuat otomatis dari skema Zod-mu. Isi judul dan isi, jalankan, dan periksa apakah file .md-nya muncul. Lalu cek tab **Resources** dan **Prompts**. Buat server Python: mcp dev server.py.


Aturan mainnya: kalau Inspector tidak bisa melihat tool-mu, Claude juga tidak akan bisa. Jangan lanjut sebelum Inspector menunjukkan kedua tool, satu resource, dan satu prompt dengan benar.



## Sambungkan ke Claude Code


Server sudah jalan dan sudah lolos Inspector. Sambungkan ke Claude Code dengan satu perintah dari terminal — bukan dari dalam sesi Claude Code:


claude mcp add --transport stdio catatan -- node /ABSOLUTE/PATH/catatan-mcp/build/index.js
Tanda -- memisahkan opsi milik Claude dari perintah yang menjalankan servermu, dan path-nya harus absolut — client bisa menjalankan server dari direktori mana pun. Kalau folder catatanmu bukan di lokasi default, tambahkan environment variable-nya dengan flag -e:


claude mcp add --transport stdio catatan -e CATATAN_FOLDER=/home/kamu/dokumen/catatan -- node /ABSOLUTE/PATH/catatan-mcp/build/index.js
Perintah itu menyimpan server di scope **local** (default). Ada dua scope lain:





| **Scope**
| **Flag**
| **Siapa yang dapat**



| Local (default)
| (tanpa flag)
| Kamu, proyek ini saja



| Project
| --scope project
| Seluruh tim, ikut version control



| User
| --scope user
| Kamu, di semua proyekmu





Buat server yang dipakai satu tim, pakai scope project — file .mcp.json-nya bisa di-commit:


{
"mcpServers": {
"catatan": {
"type": "stdio",
"command": "node",
"args": ["/ABSOLUTE/PATH/catatan-mcp/build/index.js"],
"env": {
"CATATAN_FOLDER": "/home/kamu/dokumen/catatan"
}
}
}
}
Dua catatan soal file ini. **Pertama, jangan pernah menulis token atau kredensial asli di dalamnya** — file ini masuk version control, jadi pakai ekspansi environment variable buat nilai rahasia. **Kedua, Claude Code meminta persetujuan dulu sebelum memakai server dari .mcp.json di sesi interaktif**, tapi di mode non-interaktif — misalnya claude -p — server dimuat tanpa bertanya.


Verifikasi dengan claude mcp list — server catatan harus berstatus Connected — atau ketik /mcp di dalam sesi. Lalu coba: "Simpan catatan: rapat Kamis pindah ke jam 10." Claude seharusnya memanggil simpan-catatan, dan file-nya muncul di folder catatanmu. Satu hal yang akan kamu temukan: semua sub-agent ikut mewarisi tool-nya, termasuk tool yang bisa menulis file. Itu default yang disengaja, tapi buat server yang menyentuh sistem penting, kamu pasti mau menguncinya. [Cara membatasi akses tool MCP per sub-agent](https://komunitech.com/blog/tutorial/claude-code-subagents-mcp-cara-batasi-akses-tool-per-sub-agent-2026/) dibahas terpisah — nama lengkap tool-nya di sini adalah mcp__catatan__simpan-catatan dan mcp__catatan__cari-catatan.



## Sambungkan ke OpenClaw


Server yang sama bisa dipakai OpenClaw tanpa mengubah satu baris kode pun. Cara paling aman menambahkannya adalah lewat Control UI (**Settings → MCP → Add server**) atau lewat CLI:


openclaw mcp add catatan -- node /ABSOLUTE/PATH/catatan-mcp/build/index.js
openclaw mcp list
openclaw mcp doctor catatan --probe
Perintah doctor --probe itu penting: menyimpan definisi server tidak membuktikan apa-apa soal keterjangkauannya — probe itu yang membuktikan. Kalau openclaw mcp list menunjukkan servermu berjalan, agent-mu sudah bisa memanggil tool-nya. Buat server Python, ganti command-nya dengan path absolut ke interpreter di dalam virtual environment — python di PATH OpenClaw belum tentu Python yang sudah ter-install paket mcp.


Kalau kamu lebih suka mengedit ~/.openclaw/openclaw.json manual, satu hal yang perlu kamu tahu: nama kunci konfigurasinya pernah berubah antar versi — dokumentasi komunitas terbaru menuliskannya sebagai mcp.servers, sementara panduan yang lebih lama menuliskannya sebagai mcpServers. Karena itu, cara yang paling tidak berisiko adalah memakai CLI atau Control UI di atas.



## Kalau mentok: error yang paling sering


Sebagian besar kegagalan MCP server pertama berasal dari segelintir penyebab yang sama:





| **Gejala**
| **Kemungkinan penyebab**
| **Perbaikannya**



| Client bilang server tidak ditemukan / gagal start
| Path relatif, atau file build belum ada
| Pakai path absolut ke build/index.js, dan jalankan npm run build dulu



| Server terputus acak, error JSON tidak valid
| console.log atau log library ke stdout
| Semua log harus ke console.error (stderr)



| server.tool is not a function / import FastMCP gagal
| Kode tutorial v1 dipakai di SDK v2 (atau sebaliknya)
| TS: registerTool dan paket @modelcontextprotocol/server. Python: MCPServer dari mcp.server





Satu prinsip debugging yang menghemat waktu: uji berlapis. Pertama Inspector — kalau di sana jalan, servermu benar. Kedua claude mcp list atau openclaw mcp list — kalau di sana Connected, konfigurasinya benar.



## Seberapa jauh server ini bisa dibawa?


Server catatan ini sengaja kecil, tapi polanya sudah lengkap. Buat membawanya lebih jauh: **pertama, ganti sumber datanya** — tool yang sekarang membaca folder bisa membaca database atau API internal. **Kedua, tambah tool dengan hati-hati** — tiap tool baru menambah pilihan yang harus dipertimbangkan model.


**Ketiga, naik ke HTTP kalau servernya perlu dipakai banyak orang.** Factory createServer yang sama dipakai ulang lewat handler HTTP — di SDK TypeScript, createMcpHandler membangun server baru per request. Endpoint-nya jadi http://127.0.0.1:3000/mcp, dan client menyambung dengan claude mcp add --transport http catatan http://127.0.0.1:3000/mcp. Tapi ingat: handler itu tidak memeriksa Host, Origin, atau autentikasi sendiri — jangan pernah mengekspos server HTTP tanpa autentikasi ke internet.


Terakhir, soal keamanan: server MCP yang membaca folder atau database adalah jalur baru ke sistemmu. Batasi foldernya sesempit mungkin, dan jangan pernah menyambungkan server yang tidak kamu kenal asal-usulnya. Soal posisi MCP di gambaran yang lebih besar: MCP itu lapisan eksekusi, cara satu agent mengakses kemampuan. Kalau kamu membangun sistem di mana beberapa agent harus bekerja sama, di situlah [perbandingan A2A dan MCP](https://komunitech.com/blog/ai-agent/a2a-vs-mcp-standar-komunikasi-antar-ai-agent/) jadi relevan: A2A buat koordinasi antar-agent, MCP buat eksekusi ke tools dan data.



## Pertanyaan yang sering ditanya soal ini



### Apakah saya harus bisa coding buat bikin MCP server?


Ya, tapi tidak banyak: server di tutorial ini sekitar 100 baris TypeScript atau 40 baris Python. Kalau kamu cuma mau memakai server MCP yang sudah ada, kamu tidak perlu coding.



### TypeScript atau Python, mana yang sebaiknya saya pilih?


Pilih bahasa yang sudah kamu pakai sehari-hari. Kalau kamu sudah pakai Node atau Claude Code, TypeScript jalurnya paling pendek; kalau servermu membungkus script Python yang sudah ada, Python lebih cepat selesai.



### Kenapa tutorial lama yang saya ikuti tidak jalan?


Hampir pasti karena perbedaan versi SDK. Di TypeScript, server.tool() sudah digantikan registerTool; di Python, FastMCP sudah berganti nama jadi MCPServer. Cocokkan dulu versi SDK-nya sebelum menyalahkan kodemu.



### Apakah server saya bisa dipakai client selain Claude Code dan OpenClaw?


Bisa, selama client itu mengikuti spesifikasi MCP yang sama. Server yang kamu bangun sekali bisa dipakai Claude Desktop, VS Code, dan Cursor tanpa perubahan — yang beda cuma format file konfigurasinya.



### Apakah aman memberi AI akses tulis ke folder saya?


Aman kalau batasnya kamu yang tentukan. Server contoh ini cuma bisa menulis file .md di satu folder khusus, dan nama file dibersihkan dari karakter berbahaya.



### Apa bedanya MCP server dengan API biasa?


API biasa butuh kode integrasi custom buat tiap pasangan aplikasi dan sistem. MCP menstandarkan cara aplikasi AI menemukan dan memanggil kemampuan secara otomatis, sehingga model sendiri yang menyusun urutan pemakaiannya.



## Penutup: satu server kecil, satu kemampuan yang nempel terus


Yang kamu bangun hari ini cuma server catatan — dua tool, satu resource, satu prompt. Tapi pola di dalamnya adalah pola yang sama dipakai server MCP produksi: daftarkan kemampuan dengan deskripsi yang jelas, validasi argumen sebelum handler berjalan, uji di Inspector, dan batasi aksesnya sesempit mungkin.


Mulai dari yang kecil dan yang kamu pakai setiap hari: server yang membaca folder kerjamu atau mencatat hasil risetmu. Itulah server yang akan kamu rawat, dan dari sanalah kamu belajar bagian mana dari MCP yang benar-benar penting. Standarnya boleh berubah tiap tahun, tapi kemampuan membangun jembatan antara AI dan datamu sendiri itu yang nempel terus.


Kamu sendiri gimana? Sudah coba membangun MCP server sendiri, atau masih mentok di salah satu langkah di atas? Ceritain di kolom komentar — aku pengin tahu server pertama apa yang kamu bangun.



## Sumber dan bacaan lanjutan




- Spesifikasi resmi Model Context Protocol, revisi 2026-07-28: *[https://modelcontextprotocol.io/specification/2026-07-28](https://modelcontextprotocol.io/specification/2026-07-28)*

- Dokumentasi MCP TypeScript SDK v2 — quickstart "Build your first server": *[https://ts.sdk.modelcontextprotocol.io/v2/llms-full.txt](https://ts.sdk.modelcontextprotocol.io/v2/llms-full.txt)*

- Dokumentasi MCP Python SDK v2 — First steps: *[https://github.com/modelcontextprotocol/python-sdk/blob/main/docs/get-started/first-steps.md](https://github.com/modelcontextprotocol/python-sdk/blob/main/docs/get-started/first-steps.md)*

- Build an MCP Server in TypeScript, SDK v2 Tutorial (24 Oktober 2026): *[https://www.claudekit.ai/guides/build-mcp-server-typescript/](https://www.claudekit.ai/guides/build-mcp-server-typescript/)*

- Dokumentasi Claude Code — MCP: *[https://code.claude.com/docs/mcp](https://code.claude.com/docs/mcp)*

- MCP Servers — OpenClaw Docs (dokumentasi komunitas): *[https://clawdocs.org/guides/mcp-servers](https://clawdocs.org/guides/mcp-servers)*
