Panduan Pengembang untuk Google Workspace MCP Servers dan Agent Development Kit

Agen AI sangat kuat, tetapi sering kali memiliki kelemahan mendasar: mereka terputus dari tempat pekerjaan harian kita benar-benar terjadi—email, kalender, dan dokumen kita. Tanpa akses ke data langsung Anda, sebuah LLM hanyalah alat brainstorming yang sangat fasih.

Dalam tutorial ini, saya akan menunjukkan cara menjembatani kesenjangan antara model AI dan data perusahaan Anda dengan mengonfigurasi Google Workspace MCP Server, memahami kontrol keamanan terbaru, dan membangun asisten otomatis.

Pada akhir sesi, Anda akan dapat: 

• Memahami arsitektur Model Context Protocol (MCP) sebagaimana diterapkan pada Google Workspace.
• Mengonfigurasi kontrol OAuth dan akses API yang diperlukan di Google Cloud.
• Menguji konektivitas menggunakan Gemini CLI dan Google Antigravity.
• Membangun Enterprise AI Assistant di Python menggunakan Google ADK yang dapat membaca email, memeriksa kalender Anda, dan membuat draf dokumen dalam satu putaran penalaran.

Prasyarat

• Proyek Google Cloud dengan penagihan diaktifkan.
• Pengetahuan dasar tentang Python dan REST API.
• Akun Google Workspace.

Apa itu Google Workspace MCP Server?

Google Workspace MCP Server adalah implementasi standar dari Model Context Protocol (MCP) yang memungkinkan klien AI apa pun yang kompatibel (seperti Claude Desktop, Gemini CLI, atau agen kustom) untuk berinteraksi dengan aman dengan aplikasi Google Workspace.

Alih-alih pengembang menulis pembungkus REST API kustom untuk Gmail, Google Docs, Drive, dan Calendar untuk setiap proyek AI baru, server MCP mengekspose kapabilitas ini sebagai "alat" standar yang dipahami secara native oleh LLM.

Saya menyarankan untuk melihat kursus Introduction to Model Context Protocol (MCP) untuk mendapatkan pengalaman langsung dengannya. 

Biasanya, membangun alur kerja lintas aplikasi berarti menulis kode integrasi yang rapuh. Dengan MCP, Anda cukup menyerahkan alatnya kepada LLM. Agen dapat membaca utas email, melihat konflik penjadwalan dengan memeriksa kalender Anda, dan membuat ringkasan di Google Docs secara mandiri.

Keamanan dan Kontrol Admin Workspace

Saat memberikan model AI akses ke email dan file korporat, keamanan data perusahaan adalah rintangan terbesar untuk adopsi AI. 

Workspace MCP Server dibangun dari awal untuk mengatasi kekhawatiran ini.

Server ini menangani autentikasi dengan sepenuhnya mengandalkan OAuth 2.0 dan IAM Google Cloud yang ketat. 

Tidak ada "master key" generik. Agen hanya bertindak atas nama pengguna yang diautentikasi secara eksplisit, serta sepenuhnya menghormati semua izin berbagi Google Workspace dan ACL dokumen yang ada.

Selain itu, server ini memperkenalkan kontrol Admin yang tangguh. 

Administrator Workspace dapat memasukkan daftar izin (allowlist) alat MCP tertentu, memantau penggunaan API di seluruh organisasi, dan menerapkan aturan Data Loss Prevention (DLP) untuk memastikan agen tidak secara tidak sengaja membocorkan dokumen Drive atau email sensitif ke domain eksternal yang tidak berwenang.

Mengonfigurasi Akses ke Workspace MCP Server

Sebelum menulis kode, "konfigurasi" di sini berarti menyiapkan izin Google Cloud untuk mengakses server jarak jauh.

Menyiapkan proyek Google Cloud

Pertama, Anda harus mengaktifkan API Workspace standar dan layanan MCP khusus di Proyek Google Cloud Anda.

1. Buka Google Cloud Console.
2. Aktifkan Workspace API yang diperlukan: Gmail API, Google Drive API, Google Docs API, dan Google Calendar API.
3. Aktifkan layanan MCP: gmailmcp.googleapis.com, drivemcp.googleapis.com, dan calendarmcp.googleapis.com.
4. Buka APIs & Services > OAuth consent screen. Siapkan layar persetujuan untuk audiens Internal. Di bawah Data Access > Add or Remove Scopes, tambahkan secara manual cakupan berikut untuk server yang Anda rencanakan untuk digunakan:
• Google Calendar: https://www.googleapis.com/auth/calendar.calendarlist.readonly, https://www.googleapis.com/auth/calendar.events.freebusy, https://www.googleapis.com/auth/calendar.events.readonly
• Google Chat: https://www.googleapis.com/auth/chat.spaces.readonly, https://www.googleapis.com/auth/chat.memberships.readonly, https://www.googleapis.com/auth/chat.messages.readonly, https://www.googleapis.com/auth/chat.users.readstate.readonly
• Google Drive: https://www.googleapis.com/auth/drive.readonly, https://www.googleapis.com/auth/drive.file
• Gmail: https://www.googleapis.com/auth/gmail.readonly, https://www.googleapis.com/auth/gmail.compose
• People API: https://www.googleapis.com/auth/directory.readonly, https://www.googleapis.com/auth/userinfo.profile, https://www.googleapis.com/auth/contacts.readonly

Membuat kredensial pengguna

Karena data Workspace bersifat spesifik pengguna, endpoint MCP jarak jauh memerlukan header Authorization: Bearer <TOKEN> yang mewakili pengguna manusia. 

Buka APIs & Services > Credentials dan buat OAuth 2.0 Client ID (tipe Desktop Application). 

Unduh file kredensial JSON. Ini akan digunakan untuk memperoleh access token OAuth 2.0 yang diperlukan melalui alur login di browser. 

Klik Create dan salin Client ID serta Client Secret. Anda akan memerlukannya di langkah berikutnya.

Menguji Koneksi (Gemini CLI dan Antigravity)

Sebelum menulis kode agen Python yang kompleks, sangat disarankan untuk melakukan uji "Hello World" guna memverifikasi kredensial Anda dan memastikan endpoint MCP jarak jauh dapat dijangkau. 

Menguji koneksi di lingkungan yang disederhanakan membantu memisahkan masalah autentikasi dari logika aplikasi Anda. 

Walaupun kita bisa menguji koneksi menggunakan Gemini CLI dan antarmuka Google Antigravity, untuk saat ini kita akan fokus pada Gemini CLI.

Terhubung melalui Gemini CLI

Cara tercepat untuk menguji konektivitas adalah menggunakan Gemini CLI. 

Karena Workspace memerlukan autentikasi ketat, Anda mengonfigurasi endpoint dan kredensial OAuth Anda dalam file ~/.gemini/settings.json:

{
  "mcpServers": {
    "calendar": {
      "httpUrl": "https://calendarmcp.googleapis.com/mcp/v1",
      "oauth": {
        "enabled": true,
        "clientId": "<YOUR_CLIENT_ID>",
        "clientSecret": "<YOUR_CLIENT_SECRET>",
        "scopes": [
          "https://www.googleapis.com/auth/calendar.calendarlist.readonly",
          "https://www.googleapis.com/auth/calendar.events.freebusy",
          "https://www.googleapis.com/auth/calendar.events.readonly"
        ]
      }
    },
    "drive": {
      "httpUrl": "https://drivemcp.googleapis.com/mcp/v1",
      "oauth": {
        "enabled": true,
        "clientId": "<YOUR_CLIENT_ID>",
        "clientSecret": "<YOUR_CLIENT_SECRET>",
        "scopes": [
          "https://www.googleapis.com/auth/drive.readonly",
          "https://www.googleapis.com/auth/drive.file"
        ]
      }
    },
    "gmail": {
      "httpUrl": "https://gmailmcp.googleapis.com/mcp/v1",
      "oauth": {
        "enabled": true,
        "clientId": "<YOUR_CLIENT_ID>",
        "clientSecret": "<YOUR_CLIENT_SECRET>",
        "scopes": [
          "https://www.googleapis.com/auth/gmail.readonly",
          "https://www.googleapis.com/auth/gmail.compose"
        ]
      }
    }
  }
}

Setelah file settings Anda diperbarui, Anda dapat meluncurkan Gemini CLI dan menjalankan perintah /mcp list. 

Anda akan melihat server Workspace yang baru dikonfigurasi tercantum sebagai "Ready" tetapi menampilkan "(OAuth not authenticated)". 

Ini mengonfirmasi bahwa CLI berhasil membaca konfigurasi Anda dan mengetahui alat jarak jauh tersebut. 

Menjalankan uji Workspace dasar

Sekarang server telah dikenali, Anda harus melakukan autentikasi sebelum menggunakannya. Mulailah dengan menjalankan perintah autentikasi untuk endpoint Gmail Anda:

/mcp auth gmail

Ini akan memulai alur OAuth 2.0 berbasis browser. 

CLI akan mencoba membuka browser web default Anda secara otomatis, meminta Anda masuk dengan akun Google Workspace dan memberikan izin yang diminta. 

Jika browser Anda tidak terbuka secara otomatis, CLI akan menyediakan URL aman yang dapat Anda salin dan tempel secara manual. Setelah Anda menyelesaikan proses masuk, CLI akan mengonfirmasi autentikasi yang berhasil dan memuat ulang alat untuk server tersebut.

Dengan autentikasi selesai, kini Anda dapat menguji koneksi dengan prompt bahasa alami:

my email for any messages containing the word 'Invoice'.

CLI akan mengeksekusi alat di balik layar, mengambil data dari kotak masuk Anda, dan agen akan memformatnya menjadi respons yang bermanfaat:

Proyek Demo: Membangun Workspace Agent Dengan Google ADK

Mari kita bangun Workspace Agent yang terhubung ke kelima layanan (Calendar, Chat, Drive, Gmail, People) dan menangani autentikasi dengan aman.

Membuat Application Default Credentials (auth.py)

Sebelum agen dapat berjalan, ia memerlukan token OAuth untuk diteruskan ke endpoint MCP. 

Gemini CLI menangani ini secara otomatis dengan /mcp auth, tetapi untuk aplikasi Python, kita perlu membuat token sendiri dan menyimpannya sebagai Application Default Credentials (ADC).

Buat file bernama auth.py di root proyek Anda. Pastikan Anda memiliki file client_secret.json yang telah diunduh pada direktori yang sama. 

Skrip ini menggunakan google-auth-oauthlib resmi untuk menghasilkan URL autentikasi, menukar kode dengan refresh token, dan menulisnya ke path standar ~/.config/gcloud/application_default_credentials.json, tempat ADK dapat menemukannya.

import json
import os
from urllib.parse import urlparse, parse_qs
import google.auth
from google_auth_oauthlib.flow import InstalledAppFlow
CLIENT_SECRET_FILE = 'client_secret.json'
SCOPES = [
   "https://www.googleapis.com/auth/cloud-platform",
   "https://www.googleapis.com/auth/calendar",
   "https://www.googleapis.com/auth/chat.spaces.readonly",
   "https://www.googleapis.com/auth/chat.messages",
   "https://www.googleapis.com/auth/drive.readonly",
   "https://www.googleapis.com/auth/gmail.readonly",
   "https://www.googleapis.com/auth/gmail.compose",
   "https://www.googleapis.com/auth/directory.readonly",
   "https://www.googleapis.com/auth/contacts.readonly"
]
# Initialize the flow
flow = InstalledAppFlow.from_client_secrets_file(
   CLIENT_SECRET_FILE,
   scopes=SCOPES,
   redirect_uri='http://localhost:8085/'
)
# Generate Auth URL
auth_url, expected_state = flow.authorization_url(prompt='consent', access_type='offline')
print("Copy this link and paste it into your browser:\\n", auth_url)
redirected_url = input("\\nPaste the full localhost URL here: ").strip()
# Exchange code for tokens
parsed_url = urlparse(redirected_url)
code = parse_qs(parsed_url.query).get('code', [None])[0]
flow.fetch_token(code=code)
# Save ADC
adc_data = {
   "client_id": flow.credentials.client_id,
   "client_secret": flow.credentials.client_secret,
   "refresh_token": flow.credentials.refresh_token,
   "type": "authorized_user"
}
adc_path = os.path.expanduser("~/.config/gcloud/application_default_credentials.json")
os.makedirs(os.path.dirname(adc_path), exist_ok=True)
with open(adc_path, "w") as f:
   json.dump(adc_data, f, indent=2)
print(f"Success! ADC saved to: {adc_path}")

Jalankan skripnya di terminal Anda: python3 auth.py

Saat Anda mengeksekusinya, Anda perlu menyelesaikan alur autentikasi manual:

1. Skrip akan menampilkan URL OAuth Google yang panjang dimulai dengan https://accounts.google.com/o/oauth2/auth?...
2. Salin seluruh URL ini dari terminal Anda dan tempelkan ke browser web Anda.
3. Pilih akun Google Workspace Anda dan klik Allow untuk mengotorisasi aplikasi.
4. Browser Anda kemudian akan mengarahkan ke halaman localhost. Catatan: Sangat normal dan diharapkan jika browser Anda menampilkan galat "Site can't be reached" untuk halaman ini.
5. Salin seluruh URL dari bilah alamat browser Anda (URL akan dimulai dengan http://localhost:8085/?state=...&code=...).
6. Tempelkan URL lengkap itu kembali ke prompt terminal Anda pada bagian Paste the full localhost URL here: lalu tekan Enter.

Skrip akan menukar kode dengan token OAuth, menyimpannya ke ~/.config/gcloud/application_default_credentials.json, dan membuat file .env di direktori workspace_agent Anda yang berisi pengaturan Proyek Google Cloud Anda. 

Lingkungan lokal Anda sekarang sepenuhnya terautentikasi!

Membangun Agen (agent.py)

Sekarang, buat file bernama agent.py. 

Karena data Workspace sangat sensitif, server MCP mengharuskan access token yang baru saja kita buat disuntikkan ke header HTTP untuk setiap permintaan. 

Kita juga perlu mengonfigurasi lingkungan ADK secara aman.

Mari kita uraikan kodenya:

1. Lingkungan dan Caching Token (TokenRelay)

Pertama, kita memuat Application Default Credentials (ADC) pengguna yang dibuat pada langkah sebelumnya. 

Bagian penting dari agen tingkat perusahaan adalah melakukan caching token secara efisien. Jika kita menyegarkan token pada setiap eksekusi alat, kita bisa mencapai batas API atau memicu loop penyegaran tak berujung saat retry. 

Kelas TokenRelay melakukan caching token di memori dan hanya menyegarkannya saat masa berlaku tinggal 5 menit lagi.

import os
import datetime
import google.auth
from google.auth.transport.requests import Request
from google.adk.agents.llm_agent import LlmAgent
from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
# Enable graceful error handling so timeouts return as tool outputs
os.environ["ADK_ENABLE_MCP_GRACEFUL_ERROR_HANDLING"] = "1"
# Inject User ADC path globally
_adc_path = os.path.expanduser("~/.config/gcloud/application_default_credentials.json")
if not os.path.exists(_adc_path):
   raise FileNotFoundError("Please run 'python3 auth.py' first to generate credentials.")
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = _adc_path
creds, _ = google.auth.default()
class TokenRelay:
   """Manages in-memory caching of Google OAuth access tokens."""
   def __init__(self, credentials):
       self._creds = credentials
       self._cached_token = None
       self._expiry = None
   def get_token(self) -> str:
       now = datetime.datetime.now()
       if (self._cached_token is None or self._expiry is None
           or now >= (self._expiry - datetime.timedelta(minutes=5))):
           self._creds.refresh(Request())
           self._cached_token = self._creds.token
           self._expiry = now + datetime.timedelta(minutes=50)
       return self._cached_token or ""
token_relay = TokenRelay(creds)
token_relay.get_token()
def auth_header_provider(tool_context=None) -> dict[str, str]:
   return {"Authorization": f"Bearer {token_relay.get_token()}"}

2. Mengonfigurasi MCP Toolset

Dengan cache token siap, kita mengonfigurasi 5 koneksi MCP. Kita menggunakan StreamableHTTPConnectionParams untuk terhubung ke endpoint Server-Sent Events (SSE).

Yang membuat McpToolset begitu kuat adalah kemampuannya menginterogasi endpoint jarak jauh secara dinamis. Ia secara otomatis mengambil alat yang tersedia dan skema JSON-nya. Anda tidak perlu meng-hardcode apa pun!

# Initialize the 5 GWS MCP servers with dynamic runtime provider
calendar_mcp = McpToolset(
   connection_params=StreamableHTTPConnectionParams(url="https://calendarmcp.googleapis.com/mcp/v1"),
   header_provider=auth_header_provider
)
chat_mcp = McpToolset(
   connection_params=StreamableHTTPConnectionParams(url="https://chatmcp.googleapis.com/mcp/v1"),
   header_provider=auth_header_provider
)
drive_mcp = McpToolset(
   connection_params=StreamableHTTPConnectionParams(url="https://drivemcp.googleapis.com/mcp/v1"),
   header_provider=auth_header_provider
)
gmail_mcp = McpToolset(
   connection_params=StreamableHTTPConnectionParams(url="https://gmailmcp.googleapis.com/mcp/v1"),
   header_provider=auth_header_provider
)
people_mcp = McpToolset(
   connection_params=StreamableHTTPConnectionParams(url="https://people.googleapis.com/mcp/v1"),
   header_provider=auth_header_provider
)

3. Menginisialisasi Agen

Terakhir, kita membuat instance LlmAgent. Kita menggunakan model gemini-2.5-flash, menyuntikkan tanggal saat ini secara dinamis ke system prompt agar LLM memahami waktu relatif ("minggu ini", "hari ini"), dan memberinya 5 toolset.

current_date = datetime.datetime.now().strftime("%Y-%m-%d")
root_agent = LlmAgent(
   model="gemini-2.5-flash",
   name='gws_adk_agent',
   instruction=f"""You are a helpful assistant grounded in the user's Google Workspace data.
   Today's current date is {current_date}. Always calculate relative dates (like 'this week' or 'upcoming meetings') using this reference.
   Use the provided MCP tools to answer questions about their Calendar, Chat, Drive, Gmail, and Contacts.
   If a tool returns an error indicating a timeout, inform the user that the service took too long to respond.""",
   tools=[calendar_mcp, chat_mcp, drive_mcp, gmail_mcp, people_mcp]
)

Menjalankan dengan ADK Web

Alih-alih menulis loop Python kustom, kita dapat menguji dan menjalankan agen ini segera menggunakan antarmuka ADK Web bawaan. Dari terminal Anda, jalankan server web: 

adk web 

Ini akan memulai server pengembangan lokal. Buka http://localhost:8080 di browser Anda. 

Anda akan melihat agen Anda sudah termuat dan siap.

Dari UI ini, Anda dapat mengobrol dengan agen secara native dan mengamati bagaimana ia berpindah dengan mulus antara Gmail, Calendar, dan Drive untuk memenuhi permintaan Anda!

Menguji Agen di dunia nyata

Sekarang agen sudah berjalan, cobalah ajukan pertanyaan kompleks lintas fungsi yang biasanya mengharuskan Anda membuka tiga tab berbeda. 

Contohnya:

Prompt 1: Periksa kalender saya untuk besok dan ringkas topik rapat saya. Adakah dokumen relevan di Drive saya untuk rapat-rapat itu?

Yang terjadi di balik layar:

1. Agen memahami bahwa ia terlebih dahulu memerlukan data kalender, jadi ia mengeksekusi alat list_events, secara dinamis menghitung tanggal besok berdasarkan system prompt.
2. Ia mengurai respons JSON untuk menemukan judul rapat.
3. Menyadari ia memerlukan dokumen terkait, ia mengekstrak kata kunci dari judul rapat tersebut dan dengan mulus memasukkannya ke panggilan alat kedua: search_files.
4. Terakhir, ia mensintesis keluaran dari server MCP Calendar dan Drive menjadi satu pengarahan yang sangat mudah dibaca.

Alih-alih menulis pembungkus API kustom dan logika integrasi, Anda cukup mengajukan pertanyaan, dan LLM yang menyusun orkestrasi multi-langkahnya.

Prompt 2: Temukan semua email yang dikirim oleh [Masukkan Email] dalam 7 hari terakhir.

Yang terjadi di balik layar:

1. Agen mengambil permintaan bahasa alami Anda dan secara otomatis menerjemahkannya ke sintaks kueri yang tepat yang diperlukan oleh Gmail API.
2. Ia memanggil alat search_threads, meneruskan string kueri yang dihasilkan secara dinamis.
3. Ia mengambil utas terbaru, mengekstrak metadata yang relevan, dan menyajikan subjek serta tanggalnya kembali kepada Anda dengan format yang rapi.

Prompt Lain untuk Dicoba

Kemungkinannya tidak terbatas saat semua data perusahaan Anda terhubung ke mesin penalaran. 

Cobalah beberapa prompt lain ini di lingkungan lokal Anda:

• "Cari email terakhir yang saya terima dari manajer saya. Apakah mereka meminta saya melakukan sesuatu?"
• "Temukan dek slide kickoff proyek di Drive saya, baca isinya, dan beri tahu saya apa tujuan Q3-nya."
• "Adakah konflik penjadwalan di kalender saya untuk minggu depan?"

Langkah Berikutnya? Membuka Otomatisasi Perusahaan

Dengan menggabungkan Agent Development Kit milik Google dengan server MCP Workspace yang terstandarisasi, Anda baru saja membangun asisten kelas perusahaan dalam kurang dari seratus baris kode. 

Namun ini baru permulaan.

Berikut yang dibuka oleh arsitektur ini bagi pengembang dan bisnis:

1. Sistem multi-agen: Alih-alih satu agen besar, Anda dapat menggunakan ADK untuk membangun armada sub-agen khusus. Satu agen secara khusus mengelola kalender Anda dan menyelesaikan konflik penjadwalan, sementara agen lain secara ketat memantau kotak masuk tim bersama dan mengategorikan permintaan yang masuk.

2. Alat perusahaan kustom: Karena MCP adalah standar, Anda tidak terbatas pada Workspace saja. Anda dapat dengan mudah menambahkan alat MCP lain ke agen Anda—seperti server MCP Postgres untuk menanyakan database penjualan perusahaan Anda, atau server MCP Jira untuk secara otomatis membuat tiket berdasarkan pesan Chat.

3. Alur kerja otomatis: Anda dapat menggunakan agen ini di luar UI ADK Web dan melakukan deployment secara headless. Bayangkan tugas CRON terjadwal yang membangunkan agen Anda setiap pagi pukul 8, menganalisis kotak masuk dan kalender Anda, lalu mengirimkan ringkasan melalui Google Chat.

Kesimpulan

Google Workspace MCP Server menghilangkan "glue code" yang diperlukan untuk menghubungkan AI ke aplikasi produktivitas perusahaan. Dengan menyediakan endpoint jarak jauh yang aman dan dikelola penuh, server ini memberdayakan pengembang untuk membangun alur kerja agentic yang terintegrasi mendalam dan menghormati izin pengguna serta standar keamanan perusahaan sejak awal.

Pengingat Praktik Terbaik: Selalu gunakan prinsip hak istimewa paling rendah (least privilege). 

Saat menetapkan cakupan OAuth ke agen AI Anda, jangan pernah memberikan akses tulis (misalnya, https://www.googleapis.com/auth/drive.file) jika agen hanya perlu membaca data.

Siap Membangun?

Lanjutkan perjalanan belajar Anda dengan kursus DataCamp berbimbing kami:

• Building AI Agents with Google ADK
• Introduction to GCP