วิธีสร้างเซิร์ฟเวอร์ MCP ด้วย Gemini CLI และ 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 อย่างมีประสิทธิภาพ

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

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

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

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

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

  • Node.js 20 ขึ้นไป
  • ติดตั้งและเริ่มต้นใช้งาน 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 เป็นวิธีใหม่ในการพัฒนาซอฟต์แวร์ เคล็ดลับที่จะช่วยให้คุณได้รับประสบการณ์การใช้งานที่ราบรื่นและประสบความสำเร็จมีดังนี้

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

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

เลือกตัวเลือกใดตัวเลือกหนึ่งต่อไปนี้ การตั้งค่าสภาพแวดล้อมแบบเรียนรู้ด้วยตนเอง หากต้องการเรียกใช้

Codelab บนเครื่องของคุณเอง หรือเริ่ม Cloud Shell หากต้องการเรียกใช้ Codelab นี้ในระบบคลาวด์ทั้งหมด

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

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

295004821bab6a87.png

37d264871000675d.png

96d86d3d5655cdbe.png

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

เริ่มต้น Cloud Shell

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

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

เปิดใช้งาน Cloud Shell

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

ภาพหน้าจอของเทอร์มินัล Google Cloud Shell ที่แสดงว่าสภาพแวดล้อมเชื่อมต่อแล้ว

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

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 ในขั้นตอนถัดไป

  1. สร้างและเริ่มต้นไดเรกทอรีโปรเจ็กต์
mkdir godoctor && cd godoctor
go mod init godoctor
  1. ตรวจสอบสิทธิ์ด้วยข้อมูลรับรองเริ่มต้นของแอปพลิเคชัน Google Cloud โดยทำดังนี้

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

gcloud auth application-default login

4. ไฟล์บริบท (GEMINI.md)

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

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

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

เปิด IDE เพื่อสร้างไฟล์ GEMINI.md ที่มีเนื้อหาด้านล่าง หากใช้ Cloud Shell คุณจะเปิดโปรแกรมแก้ไขได้โดยใช้คำสั่งด้านล่าง

cloudshell edit .

งาน: สร้างไฟล์ชื่อ 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*.

## 6. Project structure
- cmd/ contains source code for target binaries (e.g. server, client)
- internal/ contains source code for packages not meant to be exported (e.g. internal/tools/hello)
- bin/ contains the compiled binaries
- At the root place README.md, go.mod and go.sum

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

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

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

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

เรียกใช้คำสั่ง Gemini CLI ในเชลล์

gemini

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

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

ea1ed66807150f3f.png

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

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

6289bdfb3b519fa7.png

เช่นเดียวกับ /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

2cfd761183e4b770.png

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

26c3f3f7b8bceb3f.png

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

การสร้างเซิร์ฟเวอร์ MCP "Hello World"

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

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

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

Create a Model Context Protocol (MCP) server that exposes a "hello_world" tool. This tool, when called, should return the message "Hello, MCP world!"

For the MCP implementation, you should use the official Go SDK for MCP (github.com/modelcontextprotocol/go-sdk/mcp) and use the stdio transport.

TODO:
- Download the dependency: `go get github.com/modelcontextprotocol/go-sdk/mcp`
- Inspect the documentation of the SDK: `go doc github.com/modelcontextprotocol/go-sdk/mcp`
- Build a `server` command that supports stdio transport only
- Build a `client` command that connects to the server over command transport to test the server

Acceptance Criteria:
- `./bin/client --list-tools` returns the list of server tools including "hello_world"
- `./bin/client --call-tool` "hello_world" returns the output "Hello, MCP world!"

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

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

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

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

เมื่อคุณมีการติดตั้งใช้งานที่ใช้งานได้แล้ว เราจะดำเนินการติดตั้งใช้งานเครื่องมือ "read_docs" จริง

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

TODO:
- create a package `./internal/tools/docs`
- register the tool with the MCP server
- update the client to support the "read_docs" tool by providing arguments to the tool call

Acceptance Criteria:
- `./bin/client --tools-list` show both hello_world and read_docs
- `./bin/client --tool-call read_docs fmt` returns the documentation for the `fmt` package
- `./bin/client --tool-call read_docs fmt.Println` returns the documentation for the `fmt.Println` function
- `./bin/client --tool-call read_docs github.com/modelcontextprotocol/go-sdk/mcp` returns documentation for the `mcp` package

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

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

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

  1. หากโมเดลข้ามการอ่านเอกสารในขั้นตอนใดก็ตาม ให้กด ESC แล้วแจ้งให้โมเดลอ่านเอกสาร หากคุณไม่คุ้นเคยกับ Go การเรียกใช้ "go doc" พร้อมชื่อแพ็กเกจ "go doc github.com/modelcontextprotocol/go-sdk/mcp" จะแสดงเอกสารที่ถูกต้อง
  2. โมดูลระดับบนสุด " github.com/modelcontextprotocol/go-sdk" ไม่มีเอกสารใดๆ (เนื่องจากไม่มีโค้ด Go) คุณต้องบอกโมเดลให้ค้นหาเส้นทางที่สมบูรณ์
  3. ในทางกลับกัน หากโมเดลสร้างแพ็กเกจที่ไม่มีอยู่จริง เช่น "go doc github.com/modelcontextprotocol/go-sdk/mcp/server" เพียงแค่ชี้ไปที่แพ็กเกจระดับบนสุด

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

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

retrieve the documentation for the package net/http

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

retrieve the documentation for the github.com/modelcontextprotocol/go-sdk/mcp 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 ใช้เซิร์ฟเวอร์ได้ในระยะถัดไปของการพัฒนา

  1. ขอให้ CLI อัปเดต GEMINI.md เพื่อใช้ read_docs เป็นวิธีที่ต้องการในการอ่านเอกสารประกอบ
update the GEMINI.md file to include instructions to always use the read_docs tool to retrieve documentation about Go packages or symbols. This should be done whenever seeing an import for the first time in a session or after a new dependency is installed to the project (e.g. via `go get`)
  1. ตอนนี้เราต้องรีสตาร์ท Gemini CLI เพื่อกำหนดค่าเซิร์ฟเวอร์ MCP ก่อนอื่น มาบันทึกเซสชันแชทเพื่อให้คุณกลับมาแชทต่อจากที่ค้างไว้ได้เมื่อเริ่มแชทใหม่
/chat save godoctor-workshop
  1. ออกจาก CLI โดยกด Ctrl+D 2 ครั้งหรือพิมพ์คำสั่ง /quit
  2. ในขั้นตอนก่อนหน้า ตัวแทนควรคอมไพล์ไบนารีของเซิร์ฟเวอร์ให้คุณแล้ว แต่เราจะคอมไพล์เซิร์ฟเวอร์อีกครั้งด้วยชื่ออื่นเพื่อไม่ให้ได้รับผลกระทบเมื่อเราแก้ไขซอร์สโค้ด
mkdir -p bin && go build -o ./bin/godoctor ./cmd/server
  1. กำหนดค่า Gemini CLI สำหรับเครื่องมือในเครื่อง: สร้างไฟล์ .gemini/settings.json ในรูทของโปรเจ็กต์ แล้วเพิ่มส่วน mcpServers เพื่อบอก Gemini CLI วิธีเรียกใช้เซิร์ฟเวอร์ที่คอมไพล์แล้ว
mkdir -p .gemini && touch .gemini/settings.json
  1. ตอนนี้ให้เพิ่มเนื้อหาต่อไปนี้ลงในไฟล์ใหม่โดยใช้โปรแกรมแก้ไข Cloud Shell หรือ IDE ที่คุณชื่นชอบ
{
  "mcpServers": {
    "godoctor": {
      "command": "./bin/godoctor"
    }
  }
}
  1. เปิดใช้ Gemini CLI ด้วยคำสั่ง gemini
  2. คุณควรจะเห็นว่าเครื่องมือโหลดแล้วโดยพิมพ์/mcpคำสั่ง นอกจากนี้ คุณยังแสดงคำอธิบายแบบเต็มของเครื่องมือได้โดยใช้ /mcp desc

13a5a979b9d5408d.png

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

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

fdaa342e76dc5b52.png

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

defa9d11314522d4.png

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

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

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

ตอนนี้คุณสามารถกู้คืนเซสชันแชทก่อนหน้าได้ด้วยคำสั่ง /chat resume godoctor-workshop. ซึ่งจะโหลดบริบทของเซสชันจนถึงจุดที่เราพัฒนา read_docs เสร็จสิ้น โมเดลจึงมีความรู้ที่จำเป็นในการสร้างเครื่องมือใหม่

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

เรียกใช้คำสั่งต่อไปนี้ในโหมด Shell เพื่อเปิดใช้ Vertex AI API

gcloud services enable aiplatform.googleapis.com

เมื่อคำสั่งเสร็จสิ้นแล้ว คุณจะเปลี่ยนกลับไปใช้โหมดพรอมต์ได้โดยกดปุ่ม Escape (Esc)

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

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

Add a new tool to my project called code_review. This tool should use the Gemini API on Vertex AI (with model id gemini-2.5-pro) to analyze Go code and provide a list of improvements 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".

The tool output should be text in Markdown format.

TODO:
- add the genai SDK dependency with `go get import google.golang.org/genai`
- create the tool code in ./internal/tools/code/review.go
- create a code review prompt to be used by the tool
- use go-genai with Vertex AI authentication to call gemini-2.5-pro
- register the tool with the server
- add a flag to the server to set the Google Cloud Project ID: --project
- add a flag to the server to set the Google Cloud Location: --location
- add support to the review tool in the client CLI

NOT TO DO:
- DO NOT use the package github.com/google/generative-ai-go/genai as it is DEPRECATED
- DO NOT use the package cloud.google.com/go/vertexai/genai as it has been superseded by google.golang.org/genai

Acceptance Criteria:
- `./bin/client --tools-list` show all tools including `code_review`
- `./bin/client --tool-call code_review internal/tools/code/review.go` returns the code review for the "review.go" file

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

  1. เมื่อโมเดลเริ่มทำงาน คุณอาจเห็นโมเดลขอเรียกใช้เครื่องมือ read_docs โดยอัตโนมัติเพื่อเรียกดูเอกสารประกอบสำหรับแพ็กเกจ genai หากไม่เป็นเช่นนั้น คุณสามารถขัดจังหวะกระบวนการได้ทุกเมื่อด้วยปุ่ม Escape และเตือนว่าตอนนี้มีเครื่องมือ read_docs พร้อมใช้งานแล้ว
  2. หากเห็นว่าโมเดลพยายามใช้ GenAI SDK ที่ไม่ถูกต้อง (แม้ว่าจะมีรายการ "ไม่อนุญาต" ที่ชัดเจนในพรอมต์) ให้นำโมเดลกลับไปใช้ SDK ที่ถูกต้อง

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

  1. บันทึกเซสชันแชทด้วย /chat save godoctor-workshop แล้วออกจาก CLI โดยกด Ctrl+D 2 ครั้ง
  2. คอมไพล์เซิร์ฟเวอร์อีกครั้งด้วยคำจำกัดความของเครื่องมือใหม่
go build -o ./bin/godoctor ./cmd/server
  1. อัปเดตไฟล์ .gemini/settings.json โดยใช้ IDE เพื่อรวมการกำหนดค่าสภาพแวดล้อมสำหรับ Vertex AI ดังนี้
{
  "mcpServers": {
    "godoctor": {
      "command": "./bin/godoctor",
      "env": {
        "GOOGLE_CLOUD_USE_VERTEXAI": "true",
        "GOOGLE_CLOUD_PROJECT": "<your-project-id>",
        "GOOGLE_CLOUD_LOCATION": "<your-preferred-region>"
      }
    }
  }
}
  1. เปิดใช้ Gemini CLI อีกครั้ง กู้คืนเซสชันแชทกับ /chat resume godoctor-workshop
  2. ยืนยันว่าได้เปิดใช้เครื่องมือแล้วโดยพิมพ์คำสั่ง /mcp คุณควรเห็นข้อความคล้ายกับข้อความต่อไปนี้

f78b39f95edf358a.png

  1. ตอนนี้มาทดสอบเครื่องมือ code_review กันโดยตรวจสอบไฟล์ต้นฉบับของเครื่องมือ 1 ไฟล์
Use the code_review tool to review cmd/server/main.go

    You should see something like this:

d946dcc99f5e37b9.png

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

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

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 prepare it to be deployed to Cloud Run, so we need to add support to use the Streamable HTTP transport.

TODO:
- Update server to enable Streamable HTTP via the -http flag.
- An optional -listen flag can be specified to set the port to listen
- If no -http flag is specified, the server defaults to stdio transport and -listen is ignored
- Update client to use Streamable HTTP via the -addr flag
- If no flag is specified, the client defaults to command transport
- Create a shell script test_server.sh to support testing

NOT TO DO:
- DO NOT use the HTTP+SSE protocol as it has been deprecated by the MCP specification

Acceptance Criteria
- Create a shell script that:
  - Runs the server in the background;
  - Runs the client connecting over HTTP and call list tools
  - Kills the background process
- The shell script should run without failures

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

  1. โมเดลอาจพยายามใช้ HTTP+SSE แทน ซึ่งเลิกใช้งานแล้ว หากเห็นว่ามีการส่งผ่านเส้นทางนี้ ให้เปลี่ยนเส้นทางกลับไปที่ HTTP ที่สตรีมได้
  2. Gemini CLI เวอร์ชันปัจจุบัน (0.26.0) ไม่รองรับการเรียกใช้กระบวนการในเบื้องหลัง (กระบวนการใดก็ตามที่เปิดตัวด้วย run_shell_command จะถูกปิดเมื่อการเรียกใช้เครื่องมือกลับมา) ดังนั้นเราจึงขอให้ Gemini ทำให้กระบวนการทดสอบเป็นแบบอัตโนมัติโดยใช้สคริปต์ เราวางแผนที่จะเพิ่มฟีเจอร์นี้ในอนาคตอันใกล้นี้ ซึ่งจะช่วยลดความซับซ้อนของกระบวนการทดสอบได้

ไม่บังคับ: การทดสอบเซิร์ฟเวอร์ MCP โดยใช้ HTTP

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

  1. บันทึกเซสชันและออกจาก CLI
  2. แก้ไขไฟล์ .gemini/settings.json และเปลี่ยนการกำหนดค่าให้ชี้ไปยังเซิร์ฟเวอร์ที่ทำงานในเครื่อง
"mcpServers": {
  "godoctor": {
    "httpUrl": "http://localhost:8080"
  }
}
  1. ในเทอร์มินัลที่ 2 ให้เรียกใช้เซิร์ฟเวอร์ที่เปิดใช้ HTTP ในเครื่อง
go build -o ./bin/godoctor ./cmd/server && ./bin/godoctor -listen=:8080
  1. รีสตาร์ท Gemini CLI แล้วป้อนพรอมต์เพื่อทดสอบการเชื่อมต่อ เช่น "ใช้เครื่องมือ godoctor เพื่อดูเอกสารประกอบสำหรับ fmt.Println"
  2. หยุดเซิร์ฟเวอร์ด้วย 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.25.6-alpine. The image should support the following environment variables:
- GOOGLE_CLOUD_USE_VERTEXAI
- GOOGLE_CLOUD_PROJECT
- GOOGLE_CLOUD_LOCATION

Acceptance Criteria:
- The image builds successfully
- Create a script test_docker.sh to launch the docker image in background and test the connectivity with the client:
    - Call list_tools on the client pointing to the server running on Docker
    - Call read_docs for fmt.Println
    - Stop the server
- The script should run without failures

ไม่บังคับ: ทดสอบอิมเมจ Docker ด้วยตนเอง

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

  1. สร้างคอนเทนเนอร์โดยใช้คำสั่งต่อไปนี้
docker build -t godoctor:latest .
  1. เรียกใช้คอนเทนเนอร์ในเครื่อง
docker run -p 8080:8080 -e PORT=8080 godoctor:latest
  1. ทดสอบคอนเทนเนอร์ที่ทำงาน: ในเทอร์มินัลอื่น ให้เริ่ม Gemini CLI แล้วขอให้ดึงข้อมูลเอกสาร
  2. หยุดเซิร์ฟเวอร์ด้วย Ctrl+C เมื่อทดสอบเสร็จแล้ว

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

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

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

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

Now please deploy this image to Cloud Run and return me an URL I can use to call the MCP tool. Configure Cloud Run to use the following environment variables:
- GOOGLE_CLOUD_USE_VERTEXAI: true,
- GOOGLE_CLOUD_PROJECT: <your-project-id>
- GOOGLE_CLOUD_LOCATION: <your-preferred-region>

TODO:
- Run `docker build -t gcr.io/daniela-genai-sandbox/godoctor .`
- Run `gcloud run deploy godoctor --image` with the image created above

Acceptance Criteria:
- Call list-tools with the client pointing to the CloudRun endpoint

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

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

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 ระยะไกลได้แล้ว ลองขอเอกสารประกอบสำหรับแพ็กเกจต่างๆ

นอกจากนี้ คุณยังทดสอบเครื่องมือตรวจสอบโค้ดได้ด้วย โดยทำดังนี้

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

การล้างข้อมูล

เมื่อทดสอบเสร็จแล้ว อย่าลืมล้างข้อมูลในสภาพแวดล้อม คุณสามารถบอก Gemini ให้ลบโปรเจ็กต์หรือนำการติดตั้งใช้งาน 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 ด้วยเครื่องมือ MCP ที่กำหนดเองเรียบร้อยแล้ว ทำให้เป็นผู้ช่วยพัฒนา Go ที่มีประสิทธิภาพและเฉพาะเจาะจงมากขึ้น

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