หน้านี้ได้รับการแปลโดย Cloud Translation API

วิธีสร้างผู้ช่วยเขียนโค้ดด้วย Gemini CLI, MCP และ Go

1. บทนำ

ในโค้ดแล็บนี้ คุณจะได้เรียนรู้วิธีสร้างและติดตั้งใช้งานเซิร์ฟเวอร์ Model Context Protocol (MCP) เพื่อขยายความสามารถของ Gemini CLI คุณจะสร้าง godoctor ซึ่งเป็นเซิร์ฟเวอร์ที่ใช้ Go ที่มีเครื่องมือที่กำหนดเองสำหรับการพัฒนา Go ซึ่งจะเปลี่ยน Gemini CLI จากผู้ช่วยเขียนโค้ดแบบอเนกประสงค์ให้เป็นผู้เชี่ยวชาญด้านการพัฒนา Go โดยเฉพาะ

Codelab นี้ใช้วิธีการ "อิงตามพรอมต์" คุณจะทำหน้าที่เป็นหัวหน้าทีมเทคโนโลยี โดยให้พรอมต์แก่ผู้ช่วย AI (Gemini CLI เอง) เป้าหมายของคุณคือการเรียนรู้วิธีแปลข้อกำหนดของโปรเจ็กต์เป็นพรอมต์ที่มีประสิทธิภาพ และปล่อยให้ AI จัดการรายละเอียดการใช้งาน

หัวใจสำคัญของโปรเจ็กต์นี้คือ Model Context Protocol (MCP) MCP เป็นโปรโตคอลโอเพนซอร์สที่กำหนดมาตรฐานวิธีที่โมเดลภาษาขนาดใหญ่ (LLM) เช่น Gemini สื่อสารกับเครื่องมือและบริการภายนอก โดยทำหน้าที่เป็นสะพานที่ช่วยให้ AI เข้าถึงข้อมูลในโลกแห่งความเป็นจริงและดำเนินการต่างๆ ได้นอกเหนือจากความรู้ที่มีอยู่ การสร้างเซิร์ฟเวอร์ MCP จะเป็นการสร้างปลั๊กอินที่กำหนดเองซึ่ง Gemini CLI สามารถค้นพบและใช้งานได้ ซึ่งเป็นการสอนทักษะใหม่ๆ ให้กับ Gemini CLI อย่างมีประสิทธิภาพ

สิ่งที่คุณจะได้เรียนรู้

วิธีติดตั้งและกำหนดค่า Gemini CLI
วิธีสร้างพรอมต์ที่มีประสิทธิภาพเพื่อเป็นแนวทางให้ผู้ช่วย AI ในการพัฒนาซอฟต์แวร์
วิธีระบุบริบทและหลักเกณฑ์ให้กับผู้ช่วย AI
วิธีสร้างและกำหนดค่าเซิร์ฟเวอร์ MCP เพื่อเพิ่มความสามารถของ Gemini CLI
วิธีสร้างคอนเทนเนอร์และติดตั้งใช้งานแอปพลิเคชัน Go ใน Google Cloud Run

สิ่งที่คุณต้องมี

เวิร์กช็อปนี้สามารถดำเนินการได้ทั้งหมดภายใน Google Cloud Shell ซึ่งมาพร้อมกับการติดตั้งการอ้างอิงที่จำเป็นทั้งหมดไว้ล่วงหน้า (gcloud CLI, Go, Docker, Gemini CLI)

หรือหากต้องการทำงานในเครื่องของคุณเอง คุณจะต้องมีสิ่งต่อไปนี้

Node.js 20 ขึ้นไป
โปรเจ็กต์ Google Cloud ที่เปิดใช้การเรียกเก็บเงิน
ติดตั้งและเริ่มต้นใช้งาน Google Cloud SDK (gcloud CLI) แล้ว
ติดตั้ง Go 1.24 ขึ้นไปในระบบ
ติดตั้ง Docker ในระบบแล้ว

เทคโนโลยีหลัก

ดูข้อมูลเพิ่มเติมเกี่ยวกับเทคโนโลยีที่เราจะใช้ได้ที่นี่

Gemini CLI: อินเทอร์เฟซบรรทัดคำสั่งที่ทำงานด้วยระบบ AI ซึ่งเราจะขยายการทำงาน
Model Context Protocol (MCP): โปรโตคอลโอเพนซอร์สที่ช่วยให้ Gemini CLI สื่อสารกับเครื่องมือที่กำหนดเองของเราได้
Go SDK สำหรับ MCP: ไลบรารี Go ที่เราจะใช้เพื่อติดตั้งใช้งานเซิร์ฟเวอร์ MCP

เคล็ดลับสำหรับ Codelab ที่ประสบความสำเร็จ

การทำงานร่วมกับผู้ช่วย AI เป็นวิธีใหม่ในการพัฒนาซอฟต์แวร์ เคล็ดลับที่จะช่วยให้คุณได้รับประสบการณ์การใช้งานที่ราบรื่นและประสบความสำเร็จมีดังนี้

อย่ากลัวที่จะกด ESC บางครั้ง AI จะเสนอการดำเนินการหรือโค้ดที่คุณไม่เห็นด้วย ใช้แป้น ESC เพื่อยกเลิกการดำเนินการที่แนะนำและป้อนพรอมต์ใหม่เพื่อนำทางไปยังทิศทางที่ถูกต้อง คุณคือผู้ทดสอบ
ส่งเสริมการใช้เครื่องมือ หาก AI ดูเหมือนจะสับสนหรือแต่งข้อมูลขึ้นมา ให้กระตุ้นให้ AI ใช้เครื่องมือที่มีอยู่ พรอมต์ เช่น "คุณใช้ Google Search เพื่อยืนยันได้ไหม" หรือ "ใช้เครื่องมือ read_file เพื่อทำความเข้าใจโค้ดปัจจุบันก่อนทำการเปลี่ยนแปลง" อาจมีประสิทธิภาพมาก
หลีกเลี่ยงการเปลี่ยนแปลงด้วยตนเอง พยายามให้ AI ทำงานทั้งหมด นี่คือทักษะหลักที่คุณกำลังฝึกฝน อย่างไรก็ตาม หากคุณต้องทำการเปลี่ยนแปลงด้วยตนเอง ให้บอก AI เกี่ยวกับการเปลี่ยนแปลงนั้นในภายหลัง พรอมต์ เช่น "ฉันอัปเดตไฟล์ README.md ด้วยตนเองแล้ว โปรดอ่านอีกครั้งเพื่อทบทวนความรู้" จะช่วยให้ AI ทำงานสอดคล้องกับโปรเจ็กต์ของคุณ
คุณได้ลองปิดแล้วเปิดใหม่หรือยัง ในกรณีที่พบได้ไม่บ่อยนักที่ AI พยายามบังคับเส้นทางที่กำหนดไว้กับคำสั่งของคุณ อาจเป็นเพราะบริบทเสื่อมถอย (บางครั้งเรียกว่า "บริบทเน่า") ในกรณีนี้ คุณสามารถใช้คำสั่ง "/compress" ของ Gemini CLI เพื่อลดสัญญาณรบกวนในบริบท หรือในกรณีที่รุนแรง คุณสามารถใช้คำสั่ง "/clear" เพื่อล้างประวัติเซสชันทั้งหมดได้

2. การตั้งค่าสภาพแวดล้อม

การตั้งค่าสภาพแวดล้อมแบบเรียนรู้ด้วยตนเอง

ลงชื่อเข้าใช้ Google Cloud Console แล้วสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ หากยังไม่มีบัญชี Gmail หรือ Google Workspace คุณต้องสร้างบัญชี

ชื่อโปรเจ็กต์คือชื่อที่แสดงสำหรับผู้เข้าร่วมโปรเจ็กต์นี้ ซึ่งเป็นสตริงอักขระที่ Google APIs ไม่ได้ใช้ คุณอัปเดตได้ทุกเมื่อ
รหัสโปรเจ็กต์จะไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมดและเปลี่ยนแปลงไม่ได้ (เปลี่ยนไม่ได้หลังจากตั้งค่าแล้ว) Cloud Console จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ ซึ่งโดยปกติแล้วคุณไม่จำเป็นต้องสนใจว่าสตริงนั้นคืออะไร ใน Codelab ส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (โดยปกติจะระบุเป็น PROJECT_ID) หากไม่ชอบรหัสที่สร้างขึ้น คุณอาจสร้างรหัสแบบสุ่มอีกรหัสหนึ่งได้ หรือคุณอาจลองใช้ชื่อของคุณเองและดูว่ามีชื่อนั้นหรือไม่ คุณจะเปลี่ยนแปลงรหัสนี้หลังจากขั้นตอนนี้ไม่ได้ และรหัสจะคงอยู่ตลอดระยะเวลาของโปรเจ็กต์
โปรดทราบว่ายังมีค่าที่ 3 ซึ่งคือหมายเลขโปรเจ็กต์ที่ API บางตัวใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับค่าทั้ง 3 นี้ได้ในเอกสารประกอบ

จากนั้นคุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร/API ของ Cloud การทำตาม Codelab นี้จะไม่เสียค่าใช้จ่ายมากนัก หรืออาจไม่เสียเลย หากต้องการปิดทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินนอกเหนือจากบทแนะนำนี้ คุณสามารถลบทรัพยากรที่สร้างขึ้นหรือลบโปรเจ็กต์ได้ ผู้ใช้ Google Cloud รายใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรีมูลค่า$300 USD

เริ่มต้น Cloud Shell

แม้ว่าคุณจะใช้งาน Google Cloud จากระยะไกลจากแล็ปท็อปได้ แต่ใน Codelab นี้คุณจะใช้ Google Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในระบบคลาวด์

จาก Google Cloud Console ให้คลิกไอคอน Cloud Shell ในแถบเครื่องมือด้านขวาบน

การจัดสรรและเชื่อมต่อกับสภาพแวดล้อมจะใช้เวลาเพียงไม่กี่นาที เมื่อเสร็จแล้ว คุณควรเห็นข้อความคล้ายกับตัวอย่างนี้

เครื่องเสมือนนี้มาพร้อมเครื่องมือพัฒนาทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักแบบถาวรขนาด 5 GB และทำงานบน Google Cloud ซึ่งช่วยเพิ่มประสิทธิภาพเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก คุณสามารถทำงานทั้งหมดในโค้ดแล็บนี้ได้ภายในเบราว์เซอร์ คุณไม่จำเป็นต้องติดตั้งอะไร

3. การเริ่มต้นใช้งาน Gemini CLI

ในส่วนนี้ คุณจะได้เรียนรู้เกี่ยวกับ Gemini CLI รวมถึงวิธีติดตั้งและกำหนดค่าสำหรับสภาพแวดล้อมของคุณ

Gemini CLI คืออะไร

Gemini CLI เป็นอินเทอร์เฟซบรรทัดคำสั่งที่ทำงานด้วยระบบ AI ซึ่งจะช่วยคุณในงานพัฒนาซอฟต์แวร์ที่หลากหลาย โดยสามารถเข้าใจบริบทของโปรเจ็กต์ ตอบคำถาม สร้างโค้ด และใช้เครื่องมือภายนอกเพื่อขยายขีดความสามารถ

การติดตั้ง

ติดตั้ง Gemini CLI ทั่วโลกโดยใช้ npm

npm install -g @google/gemini-cli

คุณยืนยันได้ว่าติดตั้ง CLI แล้วโดยเรียกใช้คำสั่งต่อไปนี้

gemini --version

การกำหนดค่า

ไฟล์การกำหนดค่าและตัวแปรสภาพแวดล้อมจะควบคุมลักษณะการทำงานของ Gemini CLI โดยมีไฟล์สำคัญ 2 ไฟล์ ได้แก่

GEMINI.md: ไฟล์นี้มีหลักเกณฑ์และบริบทในภาษาธรรมชาติสำหรับ AI CLI จะอ่านไฟล์นี้เพื่อทำความเข้าใจมาตรฐานและรูปแบบการเขียนโค้ดของโปรเจ็กต์
.gemini/settings.json: ไฟล์นี้ควบคุมการกำหนดค่าของ CLI รวมถึงวิธีเชื่อมต่อกับเครื่องมือภายนอก เราจะใช้ไฟล์นี้เพื่อกำหนดค่า CLI ให้ใช้เซิร์ฟเวอร์ MCP ที่เรากำลังสร้างในแล็บนี้

เราจะตั้งค่าสภาพแวดล้อมก่อน จากนั้นจึงสร้างไฟล์ GEMINI.md ระบบจะกำหนดค่าไฟล์ settings.json ในขั้นตอนถัดไป

สร้างและเริ่มต้นไดเรกทอรีโปรเจ็กต์

mkdir godoctor
cd godoctor
go mod init godoctor

ตรวจสอบสิทธิ์ด้วยข้อมูลรับรองเริ่มต้นของแอปพลิเคชัน Google Cloud โดยทำดังนี้

เราต้องเข้าสู่ระบบบัญชีที่มีสิทธิ์เข้าถึงโปรเจ็กต์ GCP ที่คุณจะใช้สำหรับโค้ดแล็บนี้

ตรวจสอบว่าได้ติดตั้งและเริ่มต้น Google Cloud SDK แล้ว
เรียกใช้คำสั่งต่อไปนี้เพื่อตั้งค่าข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน

gcloud auth application-default login

4. หลักเกณฑ์การพัฒนา

การให้คำแนะนำที่ชัดเจนแก่ผู้ช่วย AI เป็นสิ่งสำคัญเพื่อให้มั่นใจว่าผู้ช่วยจะสร้างโค้ด Go ที่มีคุณภาพสูงและเป็นสำนวน โดยสามารถทำขั้นตอนนี้ในไฟล์ GEMINI.md ได้

เป้าหมาย: สร้างไฟล์ GEMINI.md ที่จะใช้เป็นชุดกฎสำหรับผู้ช่วย AI ในระหว่างโปรเจ็กต์นี้

งาน: สร้างไฟล์ชื่อ GEMINI.md ในรูทของไดเรกทอรี godoctor แล้ววางเนื้อหาต่อไปนี้ลงในไฟล์

# Go Development Guidelines
All code contributed to this project must adhere to the following principles.

### 1. Formatting
All Go code **must** be formatted with `gofmt` before being submitted.

### 2. Naming Conventions
- **Packages:** Use short, concise, all-lowercase names.
- **Variables, Functions, and Methods:** Use `camelCase` for unexported identifiers and `PascalCase` for exported identifiers.
- **Interfaces:** Name interfaces for what they do (e.g., `io.Reader`), not with a prefix like `I`.

### 3. Error Handling
- Errors are values. Do not discard them.
- Handle errors explicitly using the `if err != nil` pattern.
- Provide context to errors using `fmt.Errorf("context: %w", err)`.

### 4. Simplicity and Clarity
- "Clear is better than clever." Write code that is easy to understand.
- Avoid unnecessary complexity and abstractions.
- Prefer returning concrete types, not interfaces.

### 5. Documentation
- All exported identifiers (`PascalCase`) **must** have a doc comment.
- Comments should explain the *why*, not the *what*.

# Agent Guidelines
- **Reading URLs:** ALWAYS read URLs provided by the user. They are not optional.

ตอนนี้สภาพแวดล้อมในการพัฒนาของคุณได้รับการตั้งค่าอย่างสมบูรณ์แล้ว

5. การสร้างครั้งแรก: เซิร์ฟเวอร์ godoc

เป้าหมายแรกของคุณคือการสร้างgodoctorเซิร์ฟเวอร์เวอร์ชันเริ่มต้น เวอร์ชันนี้ควรเป็นแอปพลิเคชันที่พร้อมใช้งานจริงและมีคุณสมบัติการใช้งานขั้นต่ำ ซึ่งมีเครื่องมือเดียวที่ชื่อ godoc ซึ่งช่วยให้ค้นหาเอกสารประกอบของ Go ได้

เป้าหมาย: สร้างเซิร์ฟเวอร์ MCP ที่พร้อมใช้งานจริงซึ่งแสดงคำสั่ง go doc เพื่อให้ LLM ค้นหาเอกสารประกอบของ Go ได้

เรียกใช้คำสั่ง Gemini CLI ใน Shell โดยทำดังนี้

gemini

เมื่อเรียกใช้ CLI เป็นครั้งแรก ระบบจะขอให้คุณเลือกโหมดการตรวจสอบสิทธิ์และธีม สำหรับโหมดการตรวจสอบสิทธิ์ ให้เลือก "เข้าสู่ระบบด้วย Google" เพื่อเข้าสู่ระบบด้วยบัญชี Google ส่วนตัว คุณจึงจะได้รับประโยชน์จากระดับฟรีที่แสนใจกว้างของ Gemini CLI คุณควรเห็นตัวเลือกในการเลือกโหมดการตรวจสอบสิทธิ์ที่คล้ายกับตัวเลือกต่อไปนี้

ในกรณีที่ต้องการเปลี่ยนตัวเลือก ให้พิมพ์ /auth แล้วกด Enter เพื่อเปิดเมนูนี้อีกครั้ง

จากนั้นระบบจะแจ้งให้คุณเลือกธีม

เช่นเดียวกับ /auth คุณยังเปลี่ยนธีมได้ในภายหลังด้วยคำสั่ง /theme

หลังจากเลือกวิธีการตรวจสอบสิทธิ์และธีมที่ต้องการแล้ว ระบบจะนำคุณไปยังพรอมต์คำสั่ง คุณพิมพ์คำสั่งได้ที่นี่ เช่น

Write a hello world application in Go.

CLI ใช้การให้เหตุผลของตัวเอง (ผ่านโมเดล Gemini เช่น Gemini Flash หรือ Gemini Pro) และเครื่องมือต่างๆ ร่วมกันเพื่อทำงาน โดยจะใช้เครื่องมือเมื่อต้องการโต้ตอบกับระบบไฟล์หรือบริการภายนอก เช่น API, ฐานข้อมูล ฯลฯ ตัวอย่างเครื่องมือที่พร้อมใช้งานหรือ "เครื่องมือภายใน" ได้แก่ read_file, write_file, web_fetch และ google_search เซิร์ฟเวอร์ MCP ที่เรากำลังสร้างจะกลายเป็นเครื่องมือที่พร้อมใช้งานใน CLI ด้วย

โดยจะขอสิทธิ์จากคุณเมื่อเรียกใช้เครื่องมือเป็นครั้งแรก คุณสามารถให้สิทธิ์แบบครั้งเดียว อนุมัติแบบครอบคลุมสำหรับเซสชันที่เหลือ หรือปฏิเสธคำขอได้ หากเป็นการดำเนินการแก้ไขไฟล์ คุณจะเห็นตัวเลือกในการแก้ไขไฟล์โดยใช้โปรแกรมแก้ไขภายนอกด้วย ในกรณีที่คุณต้องการปรับเปลี่ยน ตัวอย่างเช่น นี่คือเอาต์พุตของพรอมต์ด้านบนเพื่อสร้างโปรแกรม Hello World

นอกจากพรอมต์แล้ว คุณยังใช้คำสั่งเครื่องหมายทับได้ด้วย หากคุณพิมพ์ "/" CLI จะแสดงตัวเลือกการเติมข้อความอัตโนมัติให้คุณโดยอัตโนมัติ คุณสามารถพิมพ์คำสั่งทั้งหมดต่อหรือเลือกคำสั่งจากตัวเลือกได้ คำสั่ง /auth และ /theme ที่กล่าวถึงข้างต้นเป็นคำสั่งดังกล่าว

เมื่อคุ้นเคยกับอินเทอร์เฟซแล้ว คุณจะเริ่มงานหลักของส่วนนี้ได้ ซึ่งก็คือการขอให้ CLI เขียนเซิร์ฟเวอร์ MCP ให้เรา

การสร้างเซิร์ฟเวอร์ MCP สำหรับ Hello World

วิธีที่ดีที่สุดวิธีหนึ่งในการทำให้โมเดลสร้างสิ่งต่างๆ ได้อย่างสม่ำเสมอมากขึ้นคือการแบ่งงานที่ซับซ้อนออกเป็นขั้นตอนย่อยๆ แม้ว่าโมเดลจะสามารถทำงานที่ซับซ้อนได้ด้วยตัวเอง แต่หากไม่มีการตั้งค่าที่เหมาะสม ก็จะต้องใช้เวลานานในการค้นพบการใช้งานที่ถูกต้อง

เพื่อให้มีแนวทางที่สอดคล้องกันมากขึ้น เราจะสั่งให้สร้างเซิร์ฟเวอร์ MCP "Hello World" ก่อนที่จะใช้ฟังก์ชันที่เราต้องการ (อ่านเอกสารประกอบของ Go)

ตัวอย่างพรอมต์แสดงอยู่ด้านล่าง

Your task is to create a Model Context Protocol (MCP) server to expose a "hello world" tool. For the MCP implementation, you should use the official Go SDK for MCP and use the stdio transport.

Read these references to gather information about the technology and project structure before writing any code:
- https://github.com/modelcontextprotocol/go-sdk/blob/main/README.md
- https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle
- https://go.dev/doc/modules/layout

To test the server, use shell commands like these:
(
  echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18"}}';
  echo '{"jsonrpc":"2.0","method":"notifications/initialized","params":{}}';
  echo '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}';
) | ./bin/godoctor

โปรดทราบว่าพรอมต์ด้านบนประกอบด้วย 3 ส่วนหลักๆ ดังนี้

ข้อกำหนดของปัญหา รวมถึงสิ่งที่เราต้องการสร้างและข้อจำกัด (เช่น ใช้ SDK อย่างเป็นทางการแทน SDK อื่นๆ)
เอกสารอ้างอิงสำหรับโมเดลเพื่อช่วยให้โมเดลแยกแยะคำขอ
ขั้นตอนการทดสอบ ซึ่งใช้เป็นเกณฑ์การยอมรับสำหรับงาน

การมีองค์ประกอบทั้ง 3 นี้จะช่วยให้โมเดลบรรลุผลลัพธ์ที่ต้องการได้อย่างสม่ำเสมอมากขึ้น

การติดตั้งใช้งานเครื่องมือ Go Doc

เมื่อคุณใช้งานได้แล้ว เราจะไปใช้เครื่องมือ "go doc" จริงกัน

Add a new tool to our MCP server called "godoc" that invokes the "go doc" shell command. The tool will take a mandatory "package" argument and an optional "symbol" argument.

Read the reference for the go doc command to understand its API: https://pkg.go.dev/golang.org/x/tools/cmd/godoc

Test it by executing the call with:
  echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name": "godoc", "arguments": {"package": "fmt"} } }'
 | ./bin/godoctor

Test it using both a standard library package and an external package like "github.com/modelcontextprotocol/go-sdk/mcp", both with and without symbols.

คุณสามารถทดลองใช้พรอมต์นี้หรือลองคิดพรอมต์ของคุณเองได้

หมายเหตุ: พรอมต์ด้านบนกระตุ้นให้โมเดลใช้คำสั่งเชลล์ go doc อย่างชัดเจน เนื่องจากโค้ดเพื่อดึงข้อมูลเอกสารโดยใช้ไลบรารีมาตรฐานนั้นไม่ใช่เรื่องง่าย และโมเดลอาจต้องใช้เวลาสักพักในการค้นหาด้วยตัวเอง การใช้เครื่องมือคอมไพเลอร์ในตัวgo docช่วยประหยัดเวลาได้มากและช่วยให้เรามุ่งเน้นไปที่สิ่งที่สำคัญ นั่นคือการติดตั้งใช้งาน MCP

อินเทอร์เฟซบรรทัดคำสั่งที่เป็นประโยชน์

ทันทีที่ติดตั้งใช้งานได้ดีแล้ว คุณสามารถสั่งให้โมเดลสร้าง CLI ของ godoctor โดยใช้ไคลเอ็นต์ MCP ได้ ซึ่งจะช่วยเพิ่มประสิทธิภาพการทดสอบฟีเจอร์ด้วยการหลีกเลี่ยงการสร้างการเรียก JSON-RPC ด้วยตนเองเหมือนที่เคยทำมา

ตัวอย่างพรอมต์

Now create a godoctor-cli component that will call the MCP server using command transport. This CLI will expose all tools using subcommands and allow us to test the MCP server implementation without needing to build the JSON-RPC calls manually.

Use the reference implementation at https://github.com/modelcontextprotocol/go-sdk/blob/main/README.md to build the client.

Test it by calling from the command line:
- the hello_world tool 
- the godoc tool with a local package
- the godoc tool with a local package and symbol
- the godoc tool with an external package
- the godoc tool with an external package and symbol

ตอนนี้คุณมีชุดไคลเอ็นต์และเซิร์ฟเวอร์ที่ใช้งานได้แล้ว ในส่วนถัดไปคุณจะกำหนดค่า Gemini CLI ด้วยเซิร์ฟเวอร์ MCP ที่เพิ่งสร้างขึ้นเพื่อเริ่มใช้ประโยชน์จากเซิร์ฟเวอร์ดังกล่าวในงานการเขียนโค้ดถัดไป

แหล่งข้อมูลที่มีประโยชน์

หมายเหตุ: การเขียนโค้ดด้วย LLM เป็นประสบการณ์ที่ไม่แน่นอน ดังนั้นคุณจึงไม่ได้รับประกันว่าจะได้ผลลัพธ์ที่เหมือนกันทุกครั้ง แม้ว่าจะเรียกใช้พรอมต์ที่เหมือนกัน 2 รายการในสภาพแวดล้อมเดียวกันก็ตาม ด้วยเหตุนี้ การระบุเวลาที่ LLM ติดอยู่ในลูปหรือมีบริบทที่เสื่อมถอยจึงเป็นทักษะสำคัญที่ควรพัฒนา โปรดทราบว่าคุณควบคุมได้และสามารถหยุดการอ่านได้ทุกเมื่อโดยกด ESC

เนื่องจาก MCP ยังเป็นแนวคิดใหม่และ Go SDK สำหรับ MCP เป็นไลบรารีใหม่ ในขั้นตอนนี้ Gemini อาจใช้เวลานานในการค้นหาการติดตั้งใช้งานที่เหมาะสมด้วยตนเอง คุณอาจต้องให้ข้อมูลอ้างอิงต่อไปนี้แก่โมเดลเพื่อช่วยให้โมเดลคิดค้นโซลูชันที่เหมาะสม

คุณสามารถให้พรอมต์ต่อไปนี้แก่โมเดลเพื่อให้ค้นพบ SDK API ได้อย่างสม่ำเสมอมากขึ้น "ใช้คำสั่งเชลล์ go doc เพื่อค้นหา API สำหรับไลบรารี go-sdk"
หากโมเดลพยายามตรวจสอบซอร์สโค้ดของ SDK ด้วยเครื่องมือ read_file จะไม่สำเร็จเนื่องจาก Gemini CLI อ่านไฟล์นอกขอบเขตปัจจุบันไม่ได้ คุณสั่งให้ใช้คำสั่ง cat และ ls แทนได้ผ่านเครื่องมือ run_shell_command
หากโมเดลมีปัญหาในการแก้ไขข้อบกพร่องของแอปพลิเคชัน ให้สั่งให้เพิ่มการบันทึกแบบละเอียดและปรับปรุงข้อมูลตามบริบทในข้อความแสดงข้อผิดพลาด
หากวิธีอื่นๆ ไม่ได้ผล ให้ลองใช้การติดตั้งใช้งานอ้างอิงที่ https://github.com/danicat/godoctor

6. การกำหนดค่า godoctor เป็นเซิร์ฟเวอร์ MCP สำหรับ Gemini CLI

หลังจากผู้ช่วย AI สร้างโค้ดสำหรับทั้งไคลเอ็นต์และเซิร์ฟเวอร์แล้ว คุณสามารถสั่งให้รันการทดสอบด้วยตนเอง 2-3 รายการได้ เช่น

retrieve the documentation for the package net/http

ตรวจสอบว่าคุณได้ทดสอบกับทรัพยากร Dependency ภายนอก (ไม่ได้อยู่ในไลบรารีมาตรฐาน) ด้วย

retrieve the documentation for the go-sdk package

เมื่อพอใจกับผลลัพธ์แล้ว ให้สั่งให้เขียน README.md พร้อมวิธีการใช้และพัฒนาโปรเจ็กต์นี้

Now write a detailed README.md file explaining both from a user and a developer perspective how to use and to build this project.

ตอนนี้เราจะกำหนดค่าเซิร์ฟเวอร์เพื่อให้ Gemini CLI ใช้เซิร์ฟเวอร์ได้ในระยะการพัฒนาถัดไป

ขอให้ CLI อัปเดต GEMINI.md เพื่อใช้ godoc เป็นวิธีที่ต้องการในการอ่านเอกสารประกอบ

update the GEMINI.md file to use the godoc tool to retrieve documentation about Go packages or symbols. Always prefer to use godoc over WebFetch and GoogleSearch, and only use those when godoc doesn't give a clear answer.

ตอนนี้เราต้องรีสตาร์ท Gemini CLI เพื่อกำหนดค่า ก่อนอื่น มาบันทึกเซสชันแชทเพื่อให้คุณกลับมาแชทต่อจากที่ค้างไว้ได้เมื่อเริ่มแชทใหม่

/chat save workshop001

ออกจาก CLI โดยกด Ctrl+D 2 ครั้ง
คอมไพล์ไบนารีของเซิร์ฟเวอร์: สร้างไดเรกทอรี bin แล้วคอมไพล์เซิร์ฟเวอร์ godoctor ลงในไดเรกทอรีนั้น

mkdir -p bin
go build -o ./bin/godoctor ./cmd/godoctor # adjust paths as needed

กำหนดค่า Gemini CLI สำหรับเครื่องมือในเครื่อง: สร้างไฟล์ .gemini/settings.json ในรูทของโปรเจ็กต์ แล้วเพิ่มส่วน mcpServers เพื่อบอก Gemini CLI วิธีเรียกใช้เซิร์ฟเวอร์ที่คอมไพล์แล้ว

mkdir -p .gemini
touch .gemini/settings.json

ตอนนี้ ให้เพิ่มเนื้อหาต่อไปนี้ลงในไฟล์ใหม่โดยใช้โปรแกรมแก้ไขบรรทัดคำสั่ง เช่น vim หรือ nano

{
  "mcpServers": {
    "godoctor": {
      "command": "./bin/godoctor"
    }
  }
}

ตอนนี้ให้เปิดใช้ Gemini CLI แล้วกู้คืนเซสชันแชท

/chat resume workshop001

คุณควรจะเห็นว่าระบบโหลดเครื่องมือแล้วโดยกด Ctrl+T

ทดสอบการผสานรวมโดยขอให้ Gemini CLI ใช้เครื่องมือของคุณด้วยพรอมต์ เช่น "รับเอกสารประกอบสำหรับ net/http"

คุณควรเห็นข้อความคล้ายกับข้อความต่อไปนี้

หากเครื่องมือทำงานอย่างถูกต้อง คุณควรเห็นเอกสารที่ดึงข้อมูลผ่านการเรียกใช้เครื่องมือ

ขอแสดงความยินดี คุณได้สร้างเครื่องมือ MCP แล้ว แต่เรายังปรับให้มีประโยชน์มากขึ้นได้

7. การเพิ่มผู้ตรวจสอบโค้ดที่ทำงานด้วยระบบ AI

สำคัญ: หากต้องการเรียก API ด้วย Gemini คุณต้องมีโปรเจ็กต์ GCP ที่เชื่อมโยงกับบัญชีสำหรับการเรียกเก็บเงิน ในฝั่งไคลเอ็นต์ คุณจะต้องกำหนดค่าตัวแปรสภาพแวดล้อมที่ชื่อ GEMINI_API_KEY

Gemini CLI มีระดับฟรีที่ให้การเรียกโมเดล Gemini ได้อย่างจุใจ แต่หากพบ GEMINI_API_KEY แล้ว CLI จะมีตัวเลือกให้ใช้คีย์นี้เพื่อการตรวจสอบสิทธิ์แทน ซึ่งจะข้ามโควต้าของระดับฟรี

โปรดตรวจสอบว่าคุณใช้โหมดการตรวจสอบสิทธิ์ที่ถูกต้องเพื่อหลีกเลี่ยงการปิดใช้ระดับฟรี คุณเลือกโหมดการตรวจสอบสิทธิ์ได้โดยใช้คำสั่ง /auth

มาเพิ่มฟีเจอร์ที่ซับซ้อนยิ่งขึ้นซึ่งทำงานด้วยระบบ AI กันดีกว่า นั่นก็คือเครื่องมือตรวจสอบโค้ดที่ใช้ Gemini API

เป้าหมาย: เพิ่มเครื่องมือใหม่ชื่อ code_review ลงในโปรเจ็กต์ที่มีอยู่ เครื่องมือนี้จะใช้ Gemini API เพื่อวิเคราะห์โค้ด Go และให้ความคิดเห็น

ตัวอย่างพรอมต์

I want to add a new tool to my project called code_review. This tool should use the Gemini API to analyze Go code and provide a list of improvements in json format according to the best practices accepted by the Go community. The tool should take the Go code content and an optional hint as input. The hint will be used to provide additional guidance for the AI reviewer, like "focus on security" or "help me simplify this code". Please update the server to include this new tool and modify the CLI client to add a review command to use it.

Use this SDK to call Gemini: https://github.com/googleapis/go-genai

เคล็ดลับที่มีประโยชน์

เมื่อโมเดลเริ่มทำงาน คุณอาจเห็นโมเดลขอเรียกใช้เครื่องมือ godoc โดยอัตโนมัติเพื่อเรียกดูเอกสารประกอบสำหรับแพ็กเกจ genai หากไม่เป็นเช่นนั้น คุณก็สามารถขัดจังหวะกระบวนการด้วยปุ่ม Escape และเตือนว่าตอนนี้มีเครื่องมือ godoc พร้อมใช้งานแล้ว

การทดสอบเครื่องมือตรวจสอบโค้ด

เราต้องรีสตาร์ท Gemini CLI เพื่อสร้างและโหลดเซิร์ฟเวอร์ MCP ซ้ำ บันทึกเซสชันแชทด้วย /chat save workshop002 จากนั้นออกจาก CLI โดยกด Ctrl+D 2 ครั้ง
code_review เครื่องมือนี้ต้องใช้คีย์ API เนื่องจากเราจะเรียกใช้โมเดล Gemini เพื่อเขียนรีวิวให้ คุณสร้างคีย์ API ได้โดยใช้ Google AI Studio
กำหนดค่าตัวแปรสภาพแวดล้อม GEMINI_API_KEY ด้วยคีย์ API ที่สร้างในขั้นตอนด้านบน

export GEMINI_API_KEY="YOUR_API_KEY"

คอมไพล์เซิร์ฟเวอร์อีกครั้ง: หลังจากเพิ่มเครื่องมือใหม่แล้ว คุณต้องคอมไพล์ไบนารีของเซิร์ฟเวอร์อีกครั้งเพื่อให้รวมการเปลี่ยนแปลง

go build -o ./bin/godoctor ./cmd/godoctor

เปิดใช้ Gemini CLI อีกครั้ง กู้คืนเซสชันแชทกับ /chat resume workshop002
สำคัญ ตรวจสอบว่าคุณได้รับการตรวจสอบสิทธิ์ด้วยบัญชี Gmail ส่วนตัวเพื่อให้ Gemini CLI เองไม่ใช้บัญชีสำหรับการเรียกเก็บเงิน ซึ่งทำได้โดยใช้คำสั่ง /auth ดังนี้

ยืนยันว่าเปิดใช้เครื่องมือแล้วโดยกด Ctrl+T คุณควรเห็นข้อความคล้ายกับข้อความต่อไปนี้

ตอนนี้มาทดสอบเครื่องมือ code-review กันโดยตรวจสอบไฟล์ต้นฉบับของเครื่องมือ 1 ไฟล์

"ใช้เครื่องมือ godoctor เพื่อตรวจสอบไฟล์ cmd/godoctor/main.go"

    You should see something like this:

เมื่อเครื่องมือตรวจสอบโค้ดทำงานแล้ว ตอนนี้คุณสามารถแนะนำให้โมเดลใช้การปรับปรุงบางอย่างที่พบได้ เพื่อให้เวิร์กโฟลว์ "ปรับปรุงตัวเอง" ได้อย่างเต็มรูปแบบ

ตอนนี้คุณได้ยืนยันแล้วว่าเครื่องมือ code-review ใช้งานได้ ในส่วนถัดไป คุณจะได้ทำงานกับการติดตั้งใช้งานในระบบคลาวด์

วิธีล้าง GEMINI_API_KEY

บันทึกเซสชันปัจจุบันด้วย /chat save workshop003 แล้วออกจาก CLI
สำรองข้อมูลคีย์ API ไว้ในที่ปลอดภัย

export | grep GEMINI_API_KEY > env.bkp

เลิกตั้งค่า GEMINI_API_KEY

export GEMINI_API_KEY=

รีสตาร์ท CLI และโหลดเซสชันด้วย /chat resume workshop003
ขอให้โมเดลใช้การปรับปรุงการตรวจสอบโค้ด

8. เตรียมเซิร์ฟเวอร์สำหรับระบบคลาวด์

เซิร์ฟเวอร์ MCP ที่เราพัฒนาขึ้นจนถึงตอนนี้จะทำงานในเครื่องเท่านั้น ซึ่งก็ใช้ได้หากคุณกำลังพัฒนาเครื่องมือเพื่อใช้เอง แต่ในสภาพแวดล้อมขององค์กร เรามักจะต้องติดตั้งใช้งานเครื่องมือเพื่อให้ผู้พัฒนาหลายร้อยหรือหลายพันคนใช้งานได้

เราต้องแปลงเซิร์ฟเวอร์ MCP จากเซิร์ฟเวอร์ที่พูดได้เฉพาะ I/O มาตรฐานเป็นเซิร์ฟเวอร์ที่พูด HTTP ได้ และติดตั้งใช้งานในที่ที่นักพัฒนาแอปต่างๆ เข้าถึงได้ เพื่อให้เซิร์ฟเวอร์ MCP ของเราปรับขนาดได้ เพื่อบรรลุเป้าหมายนี้ เราจะใช้โหมดการรับส่งที่กำหนดไว้ในข้อกำหนด MCP เป็น HTTP ที่สตรีมได้ และใช้ Cloud Run เป็นเป้าหมายการติดตั้งใช้งาน

เป้าหมาย: ปรับโครงสร้างเซิร์ฟเวอร์ godoctor เพื่อใช้การรับส่งข้อมูล HTTP ที่สตรีมได้

ตัวอย่างพรอมต์

The godoctor server is currently using the stdio transport. I want to deploy it to Cloud Run, so I need to refactor it to use the streamable HTTP transport instead. Please modify the server to comply with the streamable HTTP specification.

แหล่งข้อมูลที่มีประโยชน์

หากโมเดลมีปัญหาในการใช้การรับส่ง HTTP ที่สตรีมได้ คุณสามารถให้ข้อมูลอ้างอิงนี้แก่โมเดลได้ https://github.com/modelcontextprotocol/go-sdk/blob/main/design/design.md
โมเดลอาจพยายามใช้ HTTP+SSE แทน ซึ่งเลิกใช้งานไปแล้ว หากเห็นว่ามีการส่งผ่านเส้นทางนี้ ให้เปลี่ยนเส้นทางกลับไปที่ HTTP ที่สตรีมได้

การทดสอบเซิร์ฟเวอร์โดยใช้ HTTP

ขอให้โมเดลอัปเดตไคลเอ็นต์ godoctor ให้ใช้ HTTP ที่สตรีมได้ด้วย เพื่อให้คุณทดสอบได้ว่ายังใช้งานได้อยู่

Now update the client to use streamable HTTP and run a test by retrieving documentation from one package

ไม่บังคับ: หากต้องการกำหนดค่า Gemini CLI ให้ใช้เซิร์ฟเวอร์ผ่าน HTTP ให้ทำดังนี้

บันทึกเซสชันและออกจาก CLI
แก้ไขไฟล์ .gemini/settings.json และเปลี่ยนการกำหนดค่าให้ชี้ไปยังเซิร์ฟเวอร์ที่ทำงานในเครื่อง

"mcpServers": {
  "godoctor": {
    "httpUrl": "http://localhost:8080"
  }
}

เรียกใช้เซิร์ฟเวอร์ที่ปรับโครงสร้างใหม่ในเครื่อง

go run ./cmd/godoctor/main.go

ในเทอร์มินัลใหม่ (เนื่องจากการดำเนินการข้างต้นจะบล็อก) ให้เริ่ม Gemini CLI และป้อนพรอมต์เพื่อทดสอบการเชื่อมต่อ เช่น "ใช้เครื่องมือ godoc เพื่อดูเอกสารประกอบสำหรับ fmt.Println"
หยุดเซิร์ฟเวอร์ด้วย Ctrl+C เมื่อทดสอบเสร็จแล้ว

9. การใส่คอนเทนเนอร์ให้กับแอปพลิเคชันด้วย Docker

ตอนนี้เซิร์ฟเวอร์ของเราใช้โปรโตคอลการรับส่งที่ถูกต้องแล้ว เราจึงสามารถใส่คอนเทนเนอร์เพื่อการติดตั้งใช้งานได้

เป้าหมาย: สร้าง Dockerfile เพื่อจัดแพ็กเกจเซิร์ฟเวอร์ godoctor เป็นอิมเมจคอนเทนเนอร์แบบพกพาที่พร้อมใช้งานจริง

ตัวอย่างพรอมต์

Please create a multi-stage Dockerfile that compiles the Go binary and copies it into a minimal golang image like golang:1.24-alpine.

การทดสอบอิมเมจ Docker

หลังจากสร้าง Dockerfile แล้ว ให้สร้างอิมเมจและเรียกใช้เพื่อให้แน่ใจว่าทำงานได้อย่างถูกต้อง คุณสั่งให้ Gemini ทำสิ่งนี้ให้คุณได้โดยทำดังนี้

build the image and test the connectivity to the server using the godoctor client

ไม่บังคับ: หากต้องการทดสอบด้วยตนเอง ให้ทำดังนี้

สร้างคอนเทนเนอร์โดยใช้คำสั่งต่อไปนี้

docker build -t godoctor:latest .

เรียกใช้คอนเทนเนอร์ในเครื่อง

docker run -p 8080:8080 -e PORT=8080 godoctor:latest

ทดสอบคอนเทนเนอร์ที่ทำงาน: ในเทอร์มินัลอื่น ให้เริ่ม Gemini CLI แล้วขอให้ดึงข้อมูลเอกสาร
หยุดเซิร์ฟเวอร์ด้วย Ctrl+C เมื่อทดสอบเสร็จแล้ว

10. การทำให้ใช้งานได้กับ Cloud Run

ตอนนี้ได้เวลาทำให้คอนเทนเนอร์ใช้งานได้ในระบบคลาวด์แล้ว

เป้าหมาย: ทำให้เซิร์ฟเวอร์ godoctor ที่เป็นคอนเทนเนอร์ใช้งานได้ใน Google Cloud Run

คำแนะนำในการเขียนพรอมต์: ขอให้ผู้ช่วย AI ระบุคำสั่ง gcloud เพื่อติดตั้งใช้งานคอนเทนเนอร์

ตัวอย่างพรอมต์

Now please deploy this image to Cloud Run and return me an URL I can use to call the MCP tool. Deploy it to us-central1 and use the project currently configured in the environment.

เมื่อการติดตั้งใช้งานเสร็จสิ้น เราจะกำหนดค่า Gemini CLI ให้ใช้เครื่องมือที่คุณเพิ่งติดตั้งใช้งาน

ขอให้ Gemini อัปเดตไฟล์ .gemini/settings.json เพื่อเปลี่ยนการกำหนดค่าเครื่องมือ MCP ให้ชี้ไปยังบริการที่ติดตั้งใช้งาน

now update the .gemini/settings.json file to use this URL for the godoctor server

ส่วนสุดท้ายของ mcpServers ควรมีลักษณะดังนี้ (อย่าลืมแทนที่ตัวยึดตำแหน่งด้วย URL ของแอป Cloud Run จริง)

"mcpServers": {
  "godoctor": {
    "httpUrl": "https://<your-cloud-run-id>.us-central1.run.app"
  }
}

การทดสอบการติดตั้งใช้งาน Cloud Run

ตอนนี้คุณพร้อมสำหรับการทดสอบแบบครบวงจรขั้นสุดท้ายแล้ว

รีสตาร์ท Gemini CLI อีกครั้ง (โดยใช้ /chat save และ /chat resume เพื่อเก็บรักษาบริบท) ตอนนี้ CLI ควรจะเรียกเซิร์ฟเวอร์ MCP ระยะไกลได้แล้ว ลองขอเอกสารประกอบสำหรับแพ็กเกจต่างๆ

เพียงโปรดทราบว่าหากต้องการใช้เครื่องมือตรวจสอบโค้ด บริการจะต้องมี GEMINI_API_KEY คุณขอให้ Gemini CLI ทำการติดตั้งใช้งานอีกครั้งด้วยสภาพแวดล้อมที่ถูกต้องได้โดยทำดังนี้

update the cloud run environment to add a GEMINI_API_KEY and use the value in @env.bkp. Then update the .gemini/settings.json file with the correct service URL

รีสตาร์ท CLI แล้วทดสอบด้วยพรอมต์

Use the godoctor tool to review the cmd/godoctor/main.go file

ตอนนี้ Gemini CLI จะเชื่อมต่อกับบริการ Cloud Run ที่ทำให้ใช้งานได้และดำเนินการตรวจสอบโค้ด

ตัวอย่างพรอมต์

I'm done with my tests on the CloudRun server, please delete this deployment for me and revert my .gemini/settings.json to use the local version.

11. ยินดีด้วย

คุณได้แนะนำผู้ช่วย AI ให้สร้าง จัดคอนเทนเนอร์ และนำเครื่องมือที่ซับซ้อนซึ่งทำงานด้วยระบบ AI ไปใช้งานเรียบร้อยแล้ว ที่สำคัญกว่านั้นคือคุณได้ฝึกฝนทักษะที่จำเป็นในการพัฒนาซอฟต์แวร์สมัยใหม่ นั่นคือการแปลงข้อกำหนดเป็นพรอมต์ที่มีประสิทธิภาพ คุณขยาย Gemini CLI ด้วยเครื่องมือที่กำหนดเองเรียบร้อยแล้ว ทำให้เป็นผู้ช่วยพัฒนา Go ที่ทรงพลังและมีความเชี่ยวชาญมากขึ้น

วิธีสร้างผู้ช่วยเขียนโค้ดด้วย Gemini CLI, MCP และ Go

1. บทนำ

สิ่งที่คุณจะได้เรียนรู้

สิ่งที่คุณต้องมี

เทคโนโลยีหลัก

เคล็ดลับสำหรับ Codelab ที่ประสบความสำเร็จ

2. การตั้งค่าสภาพแวดล้อม

การตั้งค่าสภาพแวดล้อมแบบเรียนรู้ด้วยตนเอง

เริ่มต้น Cloud Shell

3. การเริ่มต้นใช้งาน Gemini CLI

Gemini CLI คืออะไร

การติดตั้ง

การกำหนดค่า

4. หลักเกณฑ์การพัฒนา

5. การสร้างครั้งแรก: เซิร์ฟเวอร์ godoc

การสร้างเซิร์ฟเวอร์ MCP สำหรับ Hello World

การติดตั้งใช้งานเครื่องมือ Go Doc

อินเทอร์เฟซบรรทัดคำสั่งที่เป็นประโยชน์

แหล่งข้อมูลที่มีประโยชน์

6. การกำหนดค่า godoctor เป็นเซิร์ฟเวอร์ MCP สำหรับ Gemini CLI

7. การเพิ่มผู้ตรวจสอบโค้ดที่ทำงานด้วยระบบ AI

เคล็ดลับที่มีประโยชน์

การทดสอบเครื่องมือตรวจสอบโค้ด

8. เตรียมเซิร์ฟเวอร์สำหรับระบบคลาวด์

แหล่งข้อมูลที่มีประโยชน์

การทดสอบเซิร์ฟเวอร์โดยใช้ HTTP

9. การใส่คอนเทนเนอร์ให้กับแอปพลิเคชันด้วย Docker

การทดสอบอิมเมจ Docker

10. การทำให้ใช้งานได้กับ Cloud Run

การทดสอบการติดตั้งใช้งาน Cloud Run

11. ยินดีด้วย

เอกสารอ้างอิง