Build AI Agent dengan Model Context Protocol (MCP) dan Python

Model Context Protocol (MCP) dari Anthropic sedang menjadi standar baru untuk menghubungkan AI agent dengan tools eksternal seperti database, API, dan filesystem. Berbeda dengan pendekatan manual yang membutuhkan boilerplate kode untuk setiap integrasi, MCP menyediakan protokol terbuka yang memungkinkan AI model menemukan dan menggunakan tools secara dinamis. Dalam tutorial ini, kita akan membangun AI agent sederhana menggunakan Python dan MCP untuk membaca data dari filesystem.

Sumber referensi utama tutorial ini berasal dari dokumentasi resmi Anthropic MCP dan Model Context Protocol Specification.

Langkah 1: Memahami Arsitektur MCP

MCP beroperasi dengan pola client-server. MCP server bertanggung jawab untuk mengekspose capabilities seperti resources, prompts, dan tools. MCP client menghubungkan AI model dengan server tersebut melalui transport layer yang bisa berupa stdio (local) atau HTTP dengan Server-Sent Events (remote). Dalam konteks AI agent, model LLM bertindak sebagai orchestrator yang memutuskan kapan harus memanggil tool tertentu berdasarkan konteks percakapan.

Langkah 2: Setup Environment dan Install Dependencies

Pastikan Python 3.10+ sudah terinstall di sistem. Buat virtual environment baru dan install SDK official dari Anthropic:

python -m venv mcp-agent-env
source mcp-agent-env/bin/activate
pip install mcp anthropic python-dotenv

Buat file .env dan tambahkan API key dari Anthropic:

ANTHROPIC_API_KEY=sk-ant-api03-xxxxxxxx

Langkah 3: Membuat MCP Server untuk Filesystem

Buat file filesystem_server.py yang akan mengekspose tool untuk membaca direktori dan file. Gunakan decorator @mcp.tool() untuk mendefinisikan fungsi yang bisa diakses oleh client:

import os
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("filesystem")

@mcp.tool()
async def list_files(path: str) -> str:
    """List all files in a directory"""
    try:
        files = os.listdir(path)
        return "\n".join(files)
    except Exception as e:
        return f"Error: {str(e)}"

@mcp.tool()
async def read_file(path: str) -> str:
    """Read contents of a file"""
    try:
        with open(path, 'r') as f:
            return f.read()
    except Exception as e:
        return f"Error: {str(e)}"

if __name__ == "__main__":
    mcp.run(transport="stdio")

Langkah 4: Membuat MCP Client untuk AI Agent

Client akan menghubungkan server filesystem dengan Claude API. Buat file agent_client.py:

import asyncio
import os
from anthropic import Anthropic
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def main():
    server_params = StdioServerParameters(
        command="python",
        args=["filesystem_server.py"],
        env=os.environ.copy()
    )
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = await session.list_tools()
            tools_desc = []
            for tool in tools.tools:
                tools_desc.append({"name": tool.name, "description": tool.description, "input_schema": tool.inputSchema})
            client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
            response = client.messages.create(
                model="claude-3-5-sonnet-20241022",
                max_tokens=1024,
                tools=tools_desc,
                messages=[{"role": "user", "content": "List files in /tmp and read /tmp/test.txt"}]
            )
            print(response.content)

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

Langkah 5: Menghubungkan Agent dengan Tool Calling

Untuk membuat agent yang benar-benar interaktif, kita perlu menangani loop tool calling. Saat Claude merespons dengan tool_use, client harus mengeksekusi tool tersebut melalui MCP session dan mengembalikan hasilnya ke model:

async def process_with_tools(session, client, user_message):
    messages = [{"role": "user", "content": user_message}]
    tools = await session.list_tools()
    tools_desc = [{"name": t.name, "description": t.description, "input_schema": t.inputSchema} for t in tools.tools]
    while True:
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            tools=tools_desc,
            messages=messages
        )
        if response.stop_reason != "tool_use":
            return response.content[0].text
        tool_use = next(block for block in response.content if block.type == "tool_use")
        result = await session.call_tool(tool_use.name, arguments=tool_use.input)
        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": [{"type": "tool_result", "tool_use_id": tool_use.id, "content": result.content[0].text}]})

Langkah 6: Testing dan Debugging

Jalankan client untuk menguji integrasi. Pastikan server filesystem berjalan tanpa error dan file /tmp/test.txt tersedia:

echo "Hello from MCP!" > /tmp/test.txt
python agent_client.py

Jika agent berhasil merespons dengan konten file, berarti protokol MCP sudah bekerja dengan baik. Untuk debugging, aktifkan logging dengan export MCP_LOG_LEVEL=debug sebelum menjalankan script. Dokumentasi lengkap tersedia di Python SDK Repository.