GPT Actions vs MCP: Perbandingan Teknis

GPT Actions dari OpenAI dan Model Context Protocol (MCP) dari Anthropic memecahkan masalah mendasar yang sama: memungkinkan model AI memanggil tool eksternal dan API selama percakapan. Keduanya memecahkan masalah tersebut dengan cara yang sangat berbeda.

Artikel ini adalah perbandingan teknis dari kedua pendekatan. Pembahasannya mencakup arsitektur, mekanisme protokol, autentikasi, penemuan tool, dan trade-off yang penting saat memilih salah satunya (atau menggunakan keduanya).

Apa itu GPT Actions?

GPT Actions adalah mekanisme OpenAI untuk memungkinkan Custom GPTs (dan, secara lebih luas, assistant yang dibuat melalui OpenAI API) memanggil HTTP API eksternal. Konsep ini dirilis bersama GPT Store pada akhir 2023 dan berkembang dari sistem ChatGPT Plugins sebelumnya.

Ide intinya: Anda menyediakan spesifikasi OpenAPI (versi 3.0 atau 3.1) yang menjelaskan endpoint, parameter, dan skema respons API Anda. Sistem OpenAI mem-parsing spesifikasi ini dan menyajikan endpoint tersebut sebagai tool yang dapat dipanggil oleh model. Saat model memutuskan untuk memanggil salah satunya, server OpenAI membuat HTTP request atas nama pengguna.

Berikut adalah skema OpenAPI minimal yang mendefinisikan satu action untuk mencari pelanggan berdasarkan email:

openapi: "3.1.0"
info:
  title: "Customer Lookup API"
  version: "1.0.0"
servers:
  - url: "https://api.example.com"
paths:
  /customers/search:
    get:
      operationId: "searchCustomer"
      summary: "Cari pelanggan berdasarkan email"
      parameters:
        - name: "email"
          in: "query"
          required: true
          schema:
            type: "string"
            format: "email"
          description: "Alamat email pelanggan"
      responses:
        "200":
          description: "Pelanggan ditemukan"
          content:
            application/json:
              schema:
                type: "object"
                properties:
                  id:
                    type: "string"
                  name:
                    type: "string"
                  email:
                    type: "string"
                  plan:
                    type: "string"

Anda menempelkan atau mengunggah skema ini ke GPT Builder (atau mereferensikannya melalui URL), mengonfigurasi autentikasi, dan Custom GPT kini dapat memanggil GET /customers/search?email=... kapan pun model menganggapnya relevan. (Menulis spesifikasi adalah bagian yang dapat diotomatisasi: Quickchat AI, misalnya, menghasilkan action yang setara dari deskripsi satu kalimat, berdasarkan dokumentasi live API.)

Properti arsitektur utama GPT Actions:

• Eksekusi sisi server: Infrastruktur OpenAI membuat outbound HTTP call. API Anda menerima request dari rentang IP OpenAI, bukan dari browser pengguna akhir.
• OpenAPI sebagai format skema: Model menggunakan field operationId, summary, dan description dari spesifikasi OpenAPI untuk memahami kapan dan bagaimana memanggil setiap endpoint.
• Hanya REST/HTTP: Actions terbatas pada metode HTTP standar (GET, POST, PUT, DELETE, PATCH) melalui HTTPS.
• Opsi autentikasi: OAuth 2.0, API key (dikirim sebagai header atau parameter query), atau tanpa autentikasi. OpenAI menangani alur pertukaran token OAuth atas nama pengguna.
• Definisi tool statis: Kumpulan action yang tersedia ditetapkan pada waktu konfigurasi. Model tidak dapat menemukan endpoint baru saat runtime.

Apa itu MCP?

Model Context Protocol (MCP) adalah protokol terbuka, dipublikasikan oleh Anthropic pada akhir 2024, yang menstandardisasi cara aplikasi AI berkomunikasi dengan tool eksternal dan sumber data. MCP tidak terikat pada model atau vendor tertentu.

Kami menulis panduan lengkap tentang cara kerja MCP yang membahas protokol ini dari prinsip dasar. Versi singkatnya: MCP mendefinisikan arsitektur client-server di mana aplikasi AI (MCP client) terhubung ke satu atau beberapa MCP server, menemukan tool yang tersedia melalui request tools/list, dan memanggilnya melalui pesan tools/call. Komunikasi menggunakan JSON-RPC 2.0.

Berikut adalah tool pencarian pelanggan yang sama, dinyatakan sebagai definisi tool MCP:

{
  "name": "search_customer",
  "description": "Cari pelanggan berdasarkan alamat email",
  "inputSchema": {
    "type": "object",
    "properties": {
      "email": {
        "type": "string",
        "description": "Alamat email pelanggan"
      }
    },
    "required": ["email"]
  }
}

Definisi ini berada di dalam MCP server (program kecil yang membungkus logika bisnis Anda). Saat MCP client mengirim request tools/call dengan name: "search_customer" dan arguments: {"email": "user@example.com"}, server mengeksekusi kode apa pun yang berada di balik tool tersebut (API call, query database, pembacaan file) dan mengembalikan hasilnya. Jika yang ingin Anda ekspos adalah AI assistant, bukan logika bisnis mentah, Anda dapat melewati penulisan server sepenuhnya: Quickchat AI Agent Anda dapat diekspos sebagai tool MCP dengan URL yang di-host.

Perbandingan arsitektur

Kedua pendekatan berbeda dalam hal tempat kode berjalan, alur komunikasi, dan abstraksi yang diekspos.

GPT Actions: tersentralisasi, native HTTP

User <-> ChatGPT (OpenAI servers) --HTTPS--> Your API server

Model dan eksekutor action berada bersama di sisi OpenAI. Saat model memutuskan untuk memanggil action, backend OpenAI membuat HTTP request berdasarkan spesifikasi OpenAPI, mengirimkannya ke API Anda, menerima respons, lalu memasukkan hasilnya kembali ke model. Client pengguna (browser, aplikasi mobile) tidak pernah berkomunikasi langsung dengan API Anda.

Artinya:

1. API Anda harus dapat diakses secara publik melalui HTTPS (atau setidaknya dapat dijangkau dari infrastruktur OpenAI).
2. Latensi mencakup round-trip dari OpenAI ke server Anda dan kembali.
3. Semua data request/response melewati server OpenAI.

MCP: terdesentralisasi, native protokol

User <-> AI Application (MCP Client) <--JSON-RPC--> MCP Server <-> Your API / DB / service

MCP client berjalan di mana pun aplikasi AI berjalan. Untuk Claude Desktop, itu berada di mesin pengguna. Untuk AI agent yang di-host di cloud (seperti Quickchat AI), MCP client berjalan di backend agent. MCP server dapat berjalan secara lokal (berkomunikasi melalui stdio), pada jaringan yang sama, atau secara remote melalui HTTP dengan Server-Sent Events (SSE) atau transport Streamable HTTP yang lebih baru.

Artinya:

1. MCP server dapat mengakses resource lokal (file, database, layanan localhost) yang tidak diekspos ke internet publik.
2. Komunikasi bersifat dua arah. Server dapat mengirim notifikasi ke client (misalnya, saat resource berubah).
3. Protokol ini agnostik terhadap transport. MCP bekerja melalui pipe stdio, SSE, atau HTTP biasa.

Tabel perbandingan

Pembahasan teknis mendalam: contoh integrasi

Untuk membuat perbedaannya konkret, pertimbangkan tugas umum: melakukan query ke database PostgreSQL untuk pesanan pelanggan dan mengembalikan hasilnya kepada pengguna.

Pendekatan GPT Actions

Anda perlu membuat dan meng-host HTTP API di depan database Anda:

# Server API Flask (disederhanakan)
from flask import Flask, request, jsonify
import psycopg2

app = Flask(__name__)

@app.route("/orders", methods=["GET"])
def get_orders():
    customer_email = request.args.get("email")
    conn = psycopg2.connect("dbname=mydb user=myuser")
    cur = conn.cursor()
    cur.execute(
        "SELECT order_id, product, amount, status FROM orders WHERE customer_email = %s",
        (customer_email,)
    )
    rows = cur.fetchall()
    cur.close()
    conn.close()
    return jsonify([
        {"order_id": r[0], "product": r[1], "amount": float(r[2]), "status": r[3]}
        for r in rows
    ])

Kemudian Anda menulis spesifikasi OpenAPI untuk endpoint ini, men-deploy API dengan TLS, mengonfigurasi autentikasi, dan menempelkan spesifikasi ke GPT Builder. OpenAI menangani sisanya: membaca spesifikasi, menampilkan operasi yang tersedia kepada model, dan membuat HTTP call saat diperlukan.

Total setup mencakup: server API yang berjalan, endpoint HTTPS publik, spesifikasi OpenAPI, dan konfigurasi GPT Action di UI OpenAI.

Pendekatan MCP

Anda menulis MCP server yang membungkus query database yang sama:

# MCP server menggunakan mcp Python SDK
from mcp.server import Server
from mcp.types import Tool, TextContent
import psycopg2
import json

server = Server("orders-server")

@server.list_tools()
async def list_tools():
    return [
        Tool(
            name="get_orders",
            description="Cari pesanan pelanggan berdasarkan email",
            inputSchema={
                "type": "object",
                "properties": {
                    "email": {
                        "type": "string",
                        "description": "Alamat email pelanggan"
                    }
                },
                "required": ["email"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "get_orders":
        conn = psycopg2.connect("dbname=mydb user=myuser")
        cur = conn.cursor()
        cur.execute(
            "SELECT order_id, product, amount, status FROM orders WHERE customer_email = %s",
            (arguments["email"],)
        )
        rows = cur.fetchall()
        cur.close()
        conn.close()
        results = [
            {"order_id": r[0], "product": r[1], "amount": float(r[2]), "status": r[3]}
            for r in rows
        ]
        return [TextContent(type="text", text=json.dumps(results, indent=2))]

Jika MCP server berjalan secara lokal (melalui stdio), server dapat terhubung langsung ke database di localhost atau jaringan lokal. Tidak diperlukan endpoint publik. Jika server berjalan secara remote, server memerlukan endpoint HTTP, tetapi berkomunikasi menggunakan JSON-RPC melalui SSE atau Streamable HTTP, bukan REST mentah.

Total setup untuk penggunaan lokal mencakup: skrip MCP server, konfigurasi MCP client (mengarah ke command server), dan koneksi database. Tidak ada spesifikasi OpenAPI, tidak ada sertifikat TLS, tidak ada API yang menghadap publik.

Perbedaan utama dalam praktik

Jalur GPT Actions memerlukan lebih banyak infrastruktur (layanan HTTP yang di-deploy), tetapi memanfaatkan pola REST API yang sudah diketahui sebagian besar tim. Jika Anda sudah memiliki REST API, menambahkan GPT Action sebagian besar hanya soal menulis spesifikasi OpenAPI.

Jalur MCP memerlukan lebih sedikit infrastruktur untuk use case lokal, tetapi memperkenalkan protokol baru yang perlu dipelajari tim Anda. Untuk deployment remote, kebutuhan infrastrukturnya mirip dengan GPT Actions, tetapi model komunikasinya berbeda (koneksi persisten, framing JSON-RPC, notifikasi dua arah).

Cara Quickchat AI menangani kedua pendekatan

AI Actions system Quickchat AI mendukung dua jenis action berbeda yang memetakan dua paradigma ini: HTTP Request Actions dan Remote MCP Actions.

HTTP Request Actions

HTTP Request Actions secara konseptual mirip dengan GPT Actions. Anda mengonfigurasi endpoint HTTP, metode, header, parameter query, dan template body JSON. AI Agent mengumpulkan nilai parameter dari percakapan dan backend Quickchat membuat HTTP request di sisi server.

HTTP Request Action terdiri dari:

• URL endpoint dengan placeholder {{parameter}} (misalnya, https://api.hubapi.com/crm/v3/objects/contacts)
• Metode HTTP (GET, POST, PATCH, PUT, DELETE)
• Header (termasuk token otorisasi yang disubstitusi di sisi server)
• Template body JSON dengan placeholder parameter
• Parameter query dengan placeholder
• Sekumpulan parameter bertipe (string, number, boolean, float) dengan deskripsi, flag wajib, dan nilai default

Pada waktu eksekusi, AI menentukan parameter mana yang harus diisi berdasarkan konteks percakapan. Backend menyisipkan nilai parameter ke URL, header, body, dan query string, menggantikan placeholder {{param_name}}. Kemudian backend membuat HTTP request dan mengembalikan respons ke AI untuk interpretasi.

Untuk contoh mendetail, lihat panduan HubSpot AI Actions kami.

Remote MCP Actions

Remote MCP Actions menghubungkan AI Agent ke MCP server eksternal. Alih-alih mendefinisikan endpoint HTTP individual, Anda menyediakan URL MCP server dan kredensial autentikasi opsional (bearer token dan/atau header kustom). Backend Quickchat bertindak sebagai MCP client: terhubung ke server remote, menemukan tool yang tersedia melalui protocol call standar tools/list, dan menyajikannya ke model AI.

Konfigurasi memerlukan:

• URL MCP server (endpoint HTTPS yang melayani transport MCP Streamable HTTP atau SSE)
• Token autentikasi opsional
• Header kustom opsional
• Daftar tool yang ditemukan dengan toggle aktif/nonaktif individual
• Pengaturan aktivasi tool default (apakah tool yang baru ditemukan aktif secara default)

Setelah terhubung, setiap tool yang diekspos oleh MCP server tersedia bagi AI Agent selama percakapan. AI melihat nama dan deskripsi tool dari respons tools/list MCP server dan dapat memanggilnya sesuai kebutuhan. Pemilihan tool dapat dipersempit menggunakan konfigurasi allowed_tools, yang memungkinkan Anda mengaktifkan atau menonaktifkan tool tertentu dari server.

Pendekatan ini sangat berguna saat berintegrasi dengan layanan yang sudah menerbitkan MCP server (seperti Shopify’s MCP) karena Anda dapat terhubung ke server yang sudah ada, bukan membuat HTTP action individual untuk setiap endpoint.

Kapan menggunakan yang mana di Quickchat

Gunakan HTTP Request Actions saat:

• Anda berintegrasi dengan endpoint REST API tertentu
• Anda menginginkan kontrol terperinci atas format request (header, struktur body, query params)
• API tidak memiliki MCP server yang dipublikasikan
• Anda memerlukan penyisipan kredensial sisi server (seperti token OAuth untuk HubSpot, Zendesk, dll.)

Gunakan Remote MCP Actions saat:

• Layanan menerbitkan MCP server
• Anda ingin terhubung ke beberapa tool dari satu layanan dalam satu action
• Anda menginginkan penemuan tool dinamis (tool yang tersedia untuk AI dapat berubah saat MCP server diperbarui)
• Anda membangun sistem multi-agent di mana satu AI mendelegasikan ke AI lain melalui MCP

Kelebihan dan kekurangan

GPT Actions

Kelebihan:

• Teknologi yang familier. Jika Anda memiliki REST API yang sudah ada, Anda sudah memiliki sebagian besar yang diperlukan. Penulisan spesifikasi OpenAPI terdokumentasi dengan baik dan tooling-nya matang.
• Format OpenAPI diadopsi secara luas. Spesifikasi dapat dibuat otomatis dari banyak web framework (FastAPI, Express dengan swagger-jsdoc, Spring Boot dengan springdoc).
• OpenAI menangani eksekusi HTTP request, terminasi TLS, dan penanganan error di infrastruktur mereka.
• Dukungan OAuth 2.0 sudah built-in dengan refresh token otomatis.

Kekurangan:

• Terkunci ke ekosistem OpenAI. Action yang Anda buat untuk Custom GPT tidak dapat digunakan kembali dengan Claude, Gemini, atau penyedia model lain tanpa implementasi ulang.
• API Anda harus dapat diakses secara publik. Tidak ada dukungan untuk resource lokal atau private-network.
• Tidak ada penemuan tool dinamis. Menambahkan endpoint baru memerlukan pembaruan spesifikasi OpenAPI dan konfigurasi ulang GPT.
• Hanya satu arah. API Anda tidak dapat mendorong update atau notifikasi kembali ke model di luar HTTP response.
• Semua data melewati server OpenAI, yang dapat menjadi perhatian untuk workload sensitif.
• Rate limit dan timeout eksekusi dikendalikan oleh OpenAI, bukan oleh Anda.

MCP

Kelebihan:

• Agnostik vendor. MCP server yang sama berfungsi dengan Claude, Cursor, Quickchat AI, dan client lain mana pun yang mengimplementasikan protokol.
• Mendukung resource lokal. MCP server yang berjalan melalui stdio dapat mengakses file, database, dan layanan di mesin lokal tanpa mengekspos apa pun ke internet.
• Penemuan tool dinamis. AI dapat meminta daftar tool yang tersedia dari server saat runtime. Tool dapat ditambahkan, dihapus, atau diperbarui tanpa mengonfigurasi ulang client.
• Komunikasi dua arah. Server dapat memberi tahu client tentang perubahan (misalnya, file dimodifikasi, record baru dibuat).
• Sesi stateful. Koneksi bertahan di beberapa pemanggilan tool dalam satu percakapan, sehingga memungkinkan workflow yang memerlukan konteks dari call sebelumnya.
• Spesifikasi terbuka. Siapa pun dapat memeriksa, mengimplementasikan, atau memperluas protokol.

Kekurangan:

• Ekosistem lebih muda. Protokol ini dipublikasikan pada akhir 2024, sehingga tooling, dokumentasi, dan pengetahuan komunitas masih berkembang dibandingkan OpenAPI.
• Memerlukan MCP server yang berjalan. Untuk deployment remote, ini berarti meng-host layanan tambahan (meskipun dapat ringan).
• Tidak ada spesifikasi autentikasi yang distandardisasi (per awal 2026). Implementasi bervariasi antara auth berbasis token, header kustom, dan ekstensi OAuth. Spesifikasi MCP Authorization masih berkembang.
• Framing JSON-RPC menambahkan lapisan abstraksi yang mungkin terasa asing bagi tim yang terbiasa dengan REST.
• Dukungan client bervariasi. Tidak semua aplikasi AI mendukung semua transport atau fitur MCP.

Kapan menggunakan yang mana

Pilihan bergantung pada batasan Anda:

Pilih GPT Actions jika:

• Anda membangun secara eksklusif untuk ChatGPT atau OpenAI API.
• Anda sudah memiliki REST API publik dengan spesifikasi OpenAPI.
• Anda membutuhkan OAuth 2.0 ditangani oleh platform untuk Anda.
• Anda menginginkan jalur paling sederhana dari “API yang sudah ada” ke “tool yang dapat dipanggil AI.”

Pilih MCP jika:

• Anda membutuhkan tool Anda bekerja di berbagai penyedia AI.
• Anda ingin mengekspos resource lokal atau private-network ke AI tanpa membuatnya publik.
• Anda membutuhkan penemuan tool dinamis, komunikasi dua arah, atau sesi stateful.
• Anda membangun arsitektur multi-agent di mana sistem AI berbeda perlu berkoordinasi.

Gunakan keduanya jika:

• Anda memiliki REST API yang sudah ada dan ingin mengeksposnya sebagai GPT Action untuk pengguna ChatGPT, tetapi Anda juga ingin menerbitkan MCP server untuk Claude, Cursor, dan client lain. Logika bisnis yang mendasarinya dapat dibagikan; adaptor protokol adalah lapisan tipis di atasnya.

Tren konvergensi

GPT Actions dan MCP dimulai dari filosofi desain yang berbeda (native HTTP vs. native protokol), tetapi jaraknya semakin menyempit.

OpenAI menambahkan dukungan MCP ke Agents SDK pada Maret 2025, memungkinkan agent yang didukung OpenAI terhubung ke MCP server bersama function calling tradisional. Ini tidak menggantikan GPT Actions (yang tetap menjadi cara untuk menambahkan tool calling ke Custom GPTs di ChatGPT), tetapi menunjukkan bahwa OpenAI mengakui MCP sebagai standar yang layak untuk komunikasi agent-to-tool.

Di sisi MCP, protokol kini mendukung transport Streamable HTTP, yang membuat MCP server remote terlihat lebih seperti layanan HTTP tradisional. MCP server di balik endpoint Streamable HTTP tidak jauh secara arsitektural dari REST API, meskipun secara internal masih menggunakan JSON-RPC, bukan konvensi REST.

Hasil yang mungkin adalah kedua pola akan hidup berdampingan. Skema OpenAPI akan tetap menjadi cara standar untuk mendeskripsikan REST API, dan GPT Actions (atau mekanisme serupa) akan terus menjadi jembatan paling sederhana antara API tersebut dan model AI dalam ekosistem OpenAI. MCP akan tumbuh sebagai standar lintas vendor untuk integrasi tool, terutama dalam arsitektur agentic dan multi-model. Platform seperti Quickchat AI yang mendukung HTTP Request Actions dan Remote MCP Actions memberi Anda fleksibilitas untuk menggunakan pendekatan mana pun yang sesuai dengan integrasi spesifik Anda.

Bacaan lanjutan

• Spesifikasi MCP
• Cara kerja Model Context Protocol: MCP Explained
• MCP vs HTTP
• Berikan AI Agent Anda tool live dari MCP server remote: praktik langsung
• Dokumentasi OpenAI Actions
• Spesifikasi OpenAPI
• Direktori MCP server
• Tantangan membangun AI Agent di atas Shopify MCP