Golang The Series EP.144: วิธีเชื่อมต่อ OpenAI API (GPT-4o) ด้วย Go SDK แบบมือโปร

ใน EP.144 นี้ เราจะเริ่มลงมือเชื่อมต่อ Go Backend เข้ากับ GPT-4o ของ OpenAI กันครับ หลังจากที่เราคุยเรื่องทฤษฎีและช่องทางสื่อสาร (REST vs gRPC) ไปในตอนที่แล้ว วันนี้เราจะลงมือเขียนโค้ดจริงโดยใช้ SDK มาตรฐาน เพื่อให้การรับส่งข้อมูลระหว่างระบบของเรากับ OpenAI ทำงานได้อย่างเสถียรและมีความปลอดภัยตามหลักการพัฒนาซอฟต์แวร์ครับ

1Setup SDK และการจัดการ API Key ให้ปลอดภัย

กฎข้อแรกที่สำคัญที่สุดคือ "ห้าม Hardcode API Key ลงในโค้ดเด็ดขาด" เพราะถ้าคุณเผลอ Push โค้ดขึ้น GitHub เมื่อไหร่ บอทที่คอยสแกนหา Key จะนำไปใช้จนโควต้าของคุณหมดเกลี้ยงภายในเวลาไม่กี่นาทีครับ

การติดตั้ง SDK

เราจะใช้ Library ที่เป็นมาตรฐานนิยมในชุมชน Go คือ go-openai ของคุณ sashabaranov ครับ ให้รันคำสั่งนี้ใน Terminal:

Bash

go get github.com/sashabaranov/go-openai

การจัดการ Key ให้เป็นระบบ

วิธีที่ปลอดภัยและเป็นสากลคือการใช้ Environment Variables หรือเก็บไว้ในไฟล์ .env (และต้องมั่นใจว่าใส่ชื่อไฟล์ .env ไว้ใน .gitignore แล้ว เพื่อไม่ให้ไฟล์นี้ติดไปบน Server หรือ Repo ส่วนกลาง)

ตัวอย่างโค้ดการเรียกใช้:

Go

import (
    "os"
    "github.com/sashabaranov/go-openai"
)

func main() {
    // ดึงค่า Key จากระบบปฏิบัติการหรือ Environment Variable ที่เราตั้งไว้
    apiKey := os.Getenv("OPENAI_API_KEY")
    
    if apiKey == "" {
        // จัดการกรณีที่ลืมตั้งค่า Key เพื่อไม่ให้โปรแกรมทำงานผิดพลาด
        panic("กรุณาตั้งค่า OPENAI_API_KEY ใน Environment Variable")
    }

    client := openai.NewClient(apiKey)
}

Chat Completion: การส่ง Prompt และรับคำตอบ

หัวใจสำคัญของการใช้งาน GPT-4o คือการส่งข้อมูลผ่าน ChatCompletionRequest ครับ สิ่งที่เราต้องให้ความสำคัญคือการกำหนด Role (บทบาท) และ Content (เนื้อหา) ให้ชัดเจน เพื่อให้โมเดลเข้าใจบริบทของคำถาม

ตัวอย่างโค้ด:

Go

package main

import (
    "context"
    "fmt"
    "github.com/sashabaranov/go-openai"
)

func main() {
    // ... (โค้ดการสร้าง client จากข้อที่ 1)

    resp, err := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: openai.GPT4o, // ระบุรุ่นของ Model ที่ต้องการใช้
            Messages: []openai.ChatCompletionMessage{
                {
                    Role:    openai.ChatMessageRoleUser, // กำหนดว่าเป็นข้อความจากฝั่ง User
                    Content: "ช่วยอธิบายข้อดีของภาษา Go ใน 1 ประโยคหน่อย",
                },
            },
        },
    )

    if err != nil {
        fmt.Printf("เกิดข้อผิดพลาด: %v\n", err)
        return
    }

    // คำตอบจะถูกเก็บไว้ใน Choices ซึ่งปกติเราจะดึงค่าแรกสุดมาใช้งาน
    fmt.Println(resp.Choices[0].Message.Content)
}

สรุปสิ่งที่ควรรู้:

• Role: โดยทั่วไปจะมี System (กำหนดบุคลิก AI), User (คำถามจากผู้ใช้) และ Assistant (คำตอบก่อนหน้าจาก AI สำหรับทำประวัติการคุย)

• Choices: ระบบจะส่งคำตอบกลับมาเป็น Array เพราะในบางการตั้งค่า AI อาจจะสร้างคำตอบสำรองมาให้เลือก แต่ในการใช้งานพื้นฐาน เรามักจะใช้ Choices[0] เป็นหลักครับ

Streaming Mode: การรับคำตอบแบบทยอยแสดงผล (Real-time)

หากคุณต้องการให้แอปพลิเคชันแสดงคำตอบแบบค่อยๆ พิมพ์ออกมาทีละคำเหมือนในหน้าเว็บ ChatGPT คุณจำเป็นต้องใช้ Streaming Mode ครับ วิธีนี้จะช่วยลดความรู้สึกว่าระบบ "ค้าง" ระหว่างรอโมเดลประมวลผลคำตอบยาวๆ

ในภาษา Go เราจะจัดการเรื่องนี้ผ่านการวนลูปเพื่อรับข้อมูลจาก Stream จนกว่าจะจบการทำงาน

ตัวอย่างโค้ด:

Go

// สร้าง Stream แทนการเรียกใช้ CreateChatCompletion แบบปกติ
stream, err := client.CreateChatCompletionStream(context.Background(), request)
if err != nil {
    fmt.Printf("เปิด Stream ไม่สำเร็จ: %v\n", err)
    return
}
defer stream.Close() // ปิด Stream เมื่อทำงานเสร็จเพื่อคืนทรัพยากรระบบ

for {
    // วนลูปรับข้อมูลทีละส่วน (Chunk)
    response, err := stream.Recv()
    
    // ตรวจสอบว่าข้อมูลส่งมาครบหรือยัง (io.EOF คือสัญญาณว่าจบการส่ง)
    if errors.Is(err, io.EOF) {
        fmt.Println("\n[จบการรับข้อมูล]")
        break
    }

    if err != nil {
        fmt.Printf("\nเกิดข้อผิดพลาดระหว่างรับข้อมูล: %v\n", err)
        break
    }

    // ในโหมด Stream ข้อมูลคำตอบจะอยู่ในฟิลด์ Delta
    fmt.Print(response.Choices[0].Delta.Content)
}

ความแตกต่างที่สำคัญ:

• CreateChatCompletionStream: จะส่งข้อมูลกลับมาเป็นก้อนเล็กๆ (Chunks) อย่างต่อเนื่องแทนที่จะรอให้เสร็จทั้งหมด

• Delta.Content: ในโหมดปกติข้อมูลจะอยู่ใน Message.Content แต่ถ้าเป็น Streaming ข้อมูลจะถูกส่งมาใน Delta.Content แทนครับ

Error Handling: การรับมือเมื่อ API มีปัญหา

ในการใช้งานจริง เราไม่สามารถคุมปัจจัยภายนอกอย่างระบบของ OpenAI หรือความเสถียรของอินเทอร์เน็ตได้ ดังนั้นการเขียน Go ที่ดีต้องรับมือกับความผิดพลาด (Error Handling) ให้ครอบคลุม โดยเฉพาะปัญหาเรื่องโควต้าและข้อจำกัดของ API ครับ

ปัญหาที่พบบ่อย:

• Rate Limit (429): เกิดจากการส่ง Request ถี่เกินไปจนเกินเพดานที่เขากำหนด วิธีแก้คือต้องรอสักพักแล้วค่อยลองใหม่ (Exponential Backoff)

• Insufficient Quota: แจ้งเตือนว่ายอดเงินคงเหลือในบัญชีไม่พอ หรือใช้ Token เกินจำนวนที่กำหนด

ตัวอย่างการจัดการ Error แบบเจาะจง:

Go

if err != nil {
    // ตรวจสอบว่าเป็น Error จากทาง OpenAI API โดยเฉพาะหรือไม่
    var apiErr *openai.APIError
    if errors.As(err, &apiErr) {
        switch apiErr.HTTPStatusCode {
        case 429:
            // กรณีเรียกใช้งานถี่เกินไป (Rate Limit)
            fmt.Println("เรียกใช้งานบ่อยเกินไป กรุณารอสักครู่แล้วลองใหม่")
        case 401:
            // กรณี API Key ไม่ถูกต้องหรือหมดอายุ
            fmt.Println("API Key มีปัญหา กรุณาตรวจสอบการตั้งค่า")
        case 402:
            // กรณีเงินในบัญชี OpenAI หมด (Insufficient Quota)
            fmt.Println("ยอดเงินคงเหลือไม่เพียงพอ กรุณาเติมเงินในระบบ OpenAI")
        default:
            fmt.Printf("เกิดข้อผิดพลาดจาก API: %s (Status: %d)\n", apiErr.Message, apiErr.HTTPStatusCode)
        }
    } else {
        // กรณีเป็น Error ทั่วไป เช่น Network มีปัญหา
        fmt.Printf("เกิดข้อผิดพลาดทั่วไป: %v\n", err)
    }
    return
}

สรุปหลักการจัดการ:

การแยกแยะ HTTP Status Code ช่วยให้เราตัดสินใจได้ว่าโปรแกรมควรทำอย่างไรต่อ เช่น ถ้าเป็น 429 เราอาจจะเขียน Logic ให้โปรแกรมหยุดรอแล้วลองใหม่โดยอัตโนมัติ แต่ถ้าเป็น 401 หรือ 402 เราควรหยุดทำงานและแจ้งเตือนให้ Admin ทราบเพื่อแก้ไขปัญหาเรื่องบัญชีครับ

🎯 ท้าให้ลอง (Daily Mission)

เพื่อให้เข้าใจการทำงานของ Streaming และการจัดการ Client ได้ชัดเจนขึ้น ผมอยากให้ทุกคนลองสร้างโปรแกรม CLI (Command Line Interface) ง่ายๆ ด้วยตัวเองครับ

โจทย์: เขียนโปรแกรมที่รับคำถามจาก Keyboard ผ่าน fmt.Scanln หรือ bufio.NewScanner แล้วส่งไปถาม GPT-4o โดยกำหนดให้แสดงผลลัพธ์แบบ Streaming ออกมาทางหน้าจอทันที

🔥 การบ้านเพิ่มความเซียน (Level Up!)

การคุมค่าใช้จ่ายเป็นเรื่องสำคัญมากในการทำระบบ AI ครับ โจทย์เพิ่มเติม: ลองค้นหาวิธีการกำหนดค่า MaxTokens ใน ChatCompletionRequest เพื่อจำกัดความยาวของคำตอบจาก AI ไม่ให้ยาวจนเกินไป ซึ่งจะช่วยให้คุณควบคุมงบประมาณและประหยัด Token ในแต่ละ Request ได้ครับ

บทสรุป: ก้าวแรกสู่โลกของ AI-Powered Application

การเชื่อมต่อกับ GPT-4o ผ่าน SDK ในภาษา Go ไม่ใช่เรื่องยาก แต่สิ่งที่ทำให้โปรแกรมเมอร์มืออาชีพต่างจากมือใหม่ คือการให้ความสำคัญกับ ระบบความปลอดภัย และการจัดการ User Experience ที่ดีครับ การเก็บ Key ให้มิดชิดและการเลือกใช้ Streaming Mode จะช่วยให้แอปพลิเคชันของคุณดูน่าเชื่อถือและตอบโจทย์การใช้งานจริงได้มากขึ้น

อย่าลืมลองทำการบ้านเรื่องการจำกัด Token กันดูนะครับ เพราะในงานระดับ Production การคุมค่าใช้จ่าย (Cost Optimization) คือทักษะที่สำคัญไม่แพ้การเขียนโค้ดเลยครับ

ตอนต่อไป | EP.145: Local LLM with Ollama: รันโมเดลในเครื่องและควบคุมผ่าน Go

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

สิ่งที่เราจะลุยกันใน EP.145:

• Ollama Setup: วิธีติดตั้งและรันโมเดลอย่าง Llama 3 หรือ Mistral ในเครื่องตัวเอง

• Go with Ollama: การใช้ Library เพื่อสั่งการ Local LLM ผ่านภาษา Go

• Privacy & Cost: เปรียบเทียบข้อดี-ข้อเสีย เมื่อต้องเลือกใช้งานแบบ Local แทน Cloud API

สายฟรีและสาย Privacy ห้ามพลาดตอนหน้าครับ!

ฝากกดติดตามพวกเราได้ที่ Superdev Academy ในทุกช่องทางนะครับ!

• 🔵 Facebook: Superdev Academy Thailand (อัปเดตข่าวสารและบทความใหม่)

• 🎬 YouTube: Superdev Academy Channel (ติวเข้มแบบวิดีโอ)

• 📸 Instagram: @superdevacademy (เกร็ดความรู้สั้นๆ และเบื้องหลังการทำงาน)

• 🎬 TikTok: @superdevacademy (Tips & Tricks ฉบับย่อยง่าย)

• 🌐 Website: superdevacademy.com (คลังบทความและคอร์สเรียนฉบับเต็ม)