การสร้างเนื้อหาด้วยโมเดล AI

หัวใจสำคัญของ Generative AI คือโมเดล AI ตัวอย่างโมเดล Generative ที่โดดเด่นที่สุด 2 ตัวอย่าง ได้แก่ โมเดลภาษาขนาดใหญ่ (LLM) และโมเดลการสร้างรูปภาพ โมเดลเหล่านี้จะรับอินพุตที่เรียกว่าพรอมต์ (โดยปกติแล้วจะเป็นข้อความ รูปภาพ หรือทั้ง 2 อย่างรวมกัน) แล้วสร้างเอาต์พุตเป็นข้อความ รูปภาพ หรือแม้แต่เสียงหรือวิดีโอ

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

นอกจากนี้ LLM ยังพิสูจน์แล้วว่าสามารถทำงานได้มากกว่าการสร้างข้อความง่ายๆ ดังนี้

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

มีอุปกรณ์หลายรุ่นให้คุณเลือกใช้จากผู้ให้บริการหลายราย โมเดลแต่ละรูปแบบจะมีจุดแข็งและจุดอ่อนเป็นของตัวเอง และโมเดลหนึ่งอาจทำงานอย่างใดอย่างหนึ่งได้ดี แต่ทำงานอย่างอื่นได้ไม่ดีนัก แอปที่ใช้ Generative AI มักจะได้รับประโยชน์จากการใช้โมเดลหลายแบบที่แตกต่างกัน ทั้งนี้ขึ้นอยู่กับงานที่ทำอยู่

ในฐานะนักพัฒนาแอป คุณมักจะไม่โต้ตอบกับโมเดล Generative AI โดยตรง แต่จะใช้ผ่านบริการที่มีให้บริการเป็น Web API แม้ว่าบริการเหล่านี้มักจะมีฟังก์ชันการทำงานคล้ายกัน แต่บริการทั้งหมดก็ให้บริการผ่าน API ที่ต่างกันและไม่เข้ากันได้ หากต้องการใช้บริการโมเดลหลายรายการ คุณต้องใช้ SDK ที่เป็นกรรมสิทธิ์ของแต่ละบริการ ซึ่งอาจใช้ร่วมกันไม่ได้ และหากต้องการอัปเกรดจากโมเดลหนึ่งเป็นโมเดลใหม่ล่าสุดที่มีประสิทธิภาพมากที่สุด คุณอาจต้องสร้างการผสานรวมนั้นใหม่ทั้งหมด

Genkit แก้ปัญหานี้ด้วยอินเทอร์เฟซเดียวที่แยกรายละเอียดการเข้าถึงบริการโมเดล Generative AI ที่เป็นไปได้ออก โดยมีการใช้งานที่สร้างไว้ล่วงหน้าหลายรายการ การสร้างแอปที่ทำงานด้วยระบบ AI โดยอิงตาม Genkit จะช่วยลดความซับซ้อนของกระบวนการเรียกใช้ Generative AI ครั้งแรก และทำให้รวมโมเดลหลายรายการเข้าด้วยกันหรือสลับโมเดลหนึ่งกับอีกโมเดลหนึ่งได้อย่างง่ายดายเมื่อโมเดลใหม่ปรากฏขึ้น

ก่อนเริ่มต้น

หากต้องการเรียกใช้ตัวอย่างโค้ดในหน้านี้ ให้ทําตามขั้นตอนในคู่มือเริ่มต้นใช้งานก่อน ตัวอย่างทั้งหมดจะถือว่าคุณได้ติดตั้ง Genkit ไว้เป็น Dependency ในโปรเจ็กต์แล้ว

รุ่นที่ Genkit รองรับ

Genkit ได้รับการออกแบบให้ยืดหยุ่นพอที่จะใช้บริการโมเดล Generative AI ใดก็ได้ ไลบรารีหลักจะกำหนดอินเทอร์เฟซทั่วไปสำหรับการทำงานกับโมเดล และปลั๊กอินโมเดลจะกำหนดรายละเอียดการใช้งานสำหรับการทำงานกับโมเดลที่เฉพาะเจาะจงและ API ของโมเดลนั้น

ทีม Genkit ดูแลรักษาปลั๊กอินสำหรับการทำงานกับโมเดลที่ Vertex AI, Google Generative AI และ Ollama ให้บริการ

กำลังโหลดและกําหนดค่าปลั๊กอินโมเดล

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

ฟังก์ชัน genkit.Generate()

ใน Genkit อินเทอร์เฟซหลักที่คุณใช้โต้ตอบกับโมเดล Generative AI คือฟังก์ชัน genkit.Generate()

การเรียกใช้ genkit.Generate() ที่ง่ายที่สุดจะระบุรูปแบบที่ต้องการใช้และพรอมต์ข้อความ

import (
    "context"
    "log"

    "github.com/firebase/genkit/go/ai"
    "github.com/firebase/genkit/go/genkit"
    "github.com/firebase/genkit/go/plugins/googlegenai"
)

func main() {
    ctx := context.Background()

    g, err := genkit.Init(ctx,
        genkit.WithPlugins(&googlegenai.GoogleAI{}),
        genkit.WithDefaultModel("googleai/gemini-2.0-flash"),
    )
    if err != nil {
        log.Fatal(err)
    }

    resp, err := genkit.Generate(ctx, g,
        ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
    )
    if err != nil {
        log.Fatal(err)
    }

    log.Println(resp.Text())
}

เมื่อคุณเรียกใช้ตัวอย่างสั้นๆ นี้ ระบบจะพิมพ์ข้อมูลการแก้ไขข้อบกพร่องบางส่วนตามด้วยเอาต์พุตของการเรียกใช้ genkit.Generate() ซึ่งโดยปกติจะเป็นข้อความ Markdown ดังตัวอย่างต่อไปนี้

## The Blackheart's Bounty

**A hearty stew of slow-cooked beef, spiced with rum and molasses, served in a
hollowed-out cannonball with a side of crusty bread and a dollop of tangy
pineapple salsa.**

**Description:** This dish is a tribute to the hearty meals enjoyed by pirates
on the high seas. The beef is tender and flavorful, infused with the warm spices
of rum and molasses. The pineapple salsa adds a touch of sweetness and acidity,
balancing the richness of the stew. The cannonball serving vessel adds a fun and
thematic touch, making this dish a perfect choice for any pirate-themed
adventure.

เรียกใช้สคริปต์อีกครั้ง คุณจะได้รับเอาต์พุตที่ต่างกัน

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

นอกจากนี้ คุณยังระบุรูปแบบสําหรับการเรียก genkit.Generate() รายการเดียวได้ด้วย โดยทำดังนี้

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.5-pro"),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)

ตัวระบุสตริงของโมเดลมีลักษณะดังนี้ providerid/modelid โดยที่รหัสผู้ให้บริการ (ในกรณีนี้คือ googleai) จะระบุปลั๊กอิน และรหัสโมเดลคือตัวระบุสตริงเฉพาะปลั๊กอินสำหรับโมเดลเวอร์ชันที่เจาะจง

ตัวอย่างเหล่านี้ยังแสดงให้เห็นถึงประเด็นสําคัญอีกอย่างหนึ่งด้วย เมื่อคุณใช้ genkit.Generate() เพื่อเรียกใช้โมเดล Generative AI การเปลี่ยนโมเดลที่ต้องการใช้ก็คือการส่งค่าอื่นไปยังพารามิเตอร์ของโมเดล การใช้ genkit.Generate() แทน SDK โมเดลเนทีฟจะช่วยให้คุณมีความยืดหยุ่นในการใช้โมเดลต่างๆ ในแอปและเปลี่ยนโมเดลในอนาคตได้ง่ายขึ้น

จนถึงตอนนี้คุณได้เห็นเพียงตัวอย่างการเรียกใช้ genkit.Generate() ที่ง่ายที่สุดเท่านั้น อย่างไรก็ตาม genkit.Generate() ยังมีอินเทอร์เฟซสำหรับการโต้ตอบขั้นสูงกับโมเดล Generative อีกด้วย ซึ่งคุณจะเห็นได้ในส่วนถัดไป

พรอมต์ของระบบ

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

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

resp, err := genkit.Generate(ctx, g,
    ai.WithSystem("You are a food industry marketing consultant."),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)

สำหรับรุ่นที่ไม่รองรับพรอมต์ของระบบ WithSystem() จะจำลองโดยแก้ไขคำขอให้ดูเหมือนพรอมต์ของระบบ

พารามิเตอร์ของโมเดล

ฟังก์ชัน genkit.Generate() จะใช้ตัวเลือก WithConfig() ซึ่งคุณระบุการตั้งค่าที่ไม่บังคับซึ่งควบคุมวิธีที่โมเดลสร้างเนื้อหาได้ ดังนี้

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.0-flash"),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
    ai.WithConfig(&googlegenai.GeminiConfig{
        MaxOutputTokens: 500,
        StopSequences:   ["<end>", "<fin>"],
        Temperature:     0.5,
        TopP:            0.4,
        TopK:            50,
    }),
)

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

พารามิเตอร์ที่ควบคุมความยาวเอาต์พุต

MaxOutputTokens

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

พารามิเตอร์โทเค็นเอาต์พุตสูงสุดจะกําหนดจํานวนโทเค็นที่จะสร้างโดยใช้ LLM โมเดลแต่ละโมเดลอาจใช้ตัวแยกวิเคราะห์ที่แตกต่างกัน แต่หลักการคร่าวๆ ที่ควรทราบคือคำภาษาอังกฤษแต่ละคำประกอบด้วยโทเค็น 2-4 รายการ

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

StopSequences

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

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

พารามิเตอร์ที่ควบคุม "ครีเอทีฟโฆษณา"

พารามิเตอร์ temperature, top-p และ top-k จะควบคุมระดับ "ความคิดสร้างสรรค์" ของโมเดลร่วมกัน ส่วนนี้จะอธิบายความหมายของพารามิเตอร์เหล่านี้อย่างคร่าวๆ แต่ประเด็นที่สําคัญกว่านั้นคือพารามิเตอร์เหล่านี้ใช้เพื่อปรับลักษณะของเอาต์พุต LLM ค่าที่เหมาะสมที่สุดสำหรับรายการเหล่านี้จะขึ้นอยู่กับเป้าหมายและค่ากําหนดของคุณ และอาจพบได้ผ่านการทดสอบเท่านั้น

อุณหภูมิ

LLM เป็นเครื่องจักรที่คาดการณ์โทเค็นโดยพื้นฐาน สำหรับลำดับโทเค็นหนึ่งๆ (เช่น พรอมต์) LLM จะคาดคะเนความน่าจะเป็นที่โทเค็นแต่ละรายการในคลังคำศัพท์จะปรากฏในลำดับถัดไป อุณหภูมิคือปัจจัยการปรับขนาดที่ใช้หารการคาดการณ์เหล่านี้ก่อนที่จะนอร์มาไลซ์ให้เป็นความน่าจะเป็นระหว่าง 0 ถึง 1

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

ค่าอุณหภูมิสูง (ค่ามากกว่า 1.0) จะบีบอัดความแตกต่างของความน่าจะเป็นระหว่างโทเค็น ส่งผลให้โมเดลมีแนวโน้มที่จะสร้างโทเค็นที่ก่อนหน้านี้ประเมินว่าไม่น่าจะเกิดขึ้น ซึ่งมักถูกมองว่าเป็นเอาต์พุตที่สร้างสรรค์มากขึ้น Model API บางรายการกำหนดอุณหภูมิสูงสุด ซึ่งมักจะเป็น 2.0

TopP

Top-p คือค่าระหว่าง 0.0 ถึง 1.0 ที่ควบคุมจํานวนโทเค็นที่เป็นไปได้ซึ่งคุณต้องการให้โมเดลพิจารณา โดยระบุความน่าจะเป็นสะสมของโทเค็น ตัวอย่างเช่น ค่า 1.0 หมายความว่าให้พิจารณาโทเค็นที่เป็นไปได้ทั้งหมด (แต่ยังคงคํานึงถึงความน่าจะเป็นของโทเค็นแต่ละรายการ) ค่า 0.4 หมายความว่าให้พิจารณาเฉพาะโทเค็นที่เป็นไปได้มากที่สุด ซึ่งความน่าจะเป็นทั้งหมดจะเท่ากับ 0.4 และยกเว้นโทเค็นที่เหลือไม่ให้พิจารณา

TopK

Top-k คือค่าจำนวนเต็มซึ่งควบคุมจำนวนโทเค็นที่เป็นไปได้ที่คุณต้องการให้โมเดลพิจารณาด้วย แต่ครั้งนี้จะระบุจำนวนโทเค็นสูงสุดอย่างชัดเจน การระบุค่า 1 หมายความว่าโมเดลควรทํางานอย่างมีลําดับ

ทดสอบพารามิเตอร์ของโมเดล

คุณสามารถทดสอบผลของพารามิเตอร์เหล่านี้ที่มีต่อเอาต์พุตที่สร้างขึ้นจากชุดค่าผสมของโมเดลและพรอมต์ต่างๆ โดยใช้ UI สําหรับนักพัฒนาซอฟต์แวร์ เริ่ม UI ของนักพัฒนาซอฟต์แวร์ด้วยคำสั่ง genkit start แล้วระบบจะโหลดโมเดลทั้งหมดที่กําหนดโดยปลั๊กอินที่กําหนดค่าไว้ในโปรเจ็กต์โดยอัตโนมัติ คุณสามารถลองพรอมต์และค่าการกําหนดค่าต่างๆ ได้อย่างรวดเร็วโดยไม่ต้องทําการเปลี่ยนแปลงเหล่านี้ในโค้ดซ้ำๆ

จับคู่รุ่นกับการกำหนดค่า

เนื่องจากผู้ให้บริการแต่ละรายหรือแม้แต่บางรุ่นอาจมีสคีมาการกําหนดค่าของตนเองหรือรับประกันการตั้งค่าบางอย่าง การตั้งค่าตัวเลือกแยกต่างหากโดยใช้ WithModelName() และ WithConfig() จึงอาจทำให้เกิดข้อผิดพลาดได้ เนื่องจาก WithConfig() ไม่ได้เป็นแบบคงที่กับ WithModelName()

หากต้องการจับคู่โมเดลกับการกำหนดค่า ให้สร้างการอ้างอิงโมเดลที่ส่งผ่านไปยังการเรียกใช้ generate แทน

model := googlegenai.GoogleAIModelRef("gemini-2.0-flash", &googlegenai.GeminiConfig{
    MaxOutputTokens: 500,
    StopSequences:   ["<end>", "<fin>"],
    Temperature:     0.5,
    TopP:            0.4,
    TopK:            50,
})

resp, err := genkit.Generate(ctx, g,
    ai.WithModel(model),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)
if err != nil {
    log.Fatal(err)
}

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

เอาต์พุตที่มีโครงสร้าง

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

ใน Genkit คุณสามารถขอเอาต์พุตที่มีโครงสร้างจากโมเดลได้โดยระบุประเภทเอาต์พุตเมื่อเรียกใช้ genkit.Generate() ดังนี้

type MenuItem struct {
    Name        string   `json:"name"`
    Description string   `json:"description"`
    Calories    int      `json:"calories"`
    Allergens   []string `json:"allergens"`
}

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
    ai.WithOutputType(MenuItem{}),
)
if err != nil {
  log.Fatal(err) // One possible error is that the response does not conform to the type.
}

ประเภทเอาต์พุตของโมเดลจะระบุเป็นสคีมา JSON โดยใช้แพ็กเกจ invopop/jsonschema ซึ่งจะดำเนินการตรวจสอบประเภทรันไทม์ ซึ่งช่วยปิดช่องว่างระหว่างประเภท Go แบบคงที่กับเอาต์พุตที่คาดเดาไม่ได้ของโมเดล Generative AI ระบบนี้ช่วยให้คุณเขียนโค้ดที่เชื่อถือได้ว่าการเรียกใช้ generate ที่ประสบความสําเร็จจะแสดงผลลัพธ์ที่สอดคล้องกับประเภท Go ของคุณเสมอ

เมื่อคุณระบุประเภทเอาต์พุตใน genkit.Generate() แล้ว Genkit จะดำเนินการหลายอย่างเบื้องหลัง ดังนี้

  • เสริมพรอมต์ด้วยคําแนะนําเพิ่มเติมเกี่ยวกับรูปแบบเอาต์พุตที่เลือก นอกจากนี้ การดำเนินการนี้ยังมีผลข้างเคียงในการระบุให้โมเดลทราบว่าคุณต้องการสร้างเนื้อหาแบบใด (เช่น ไม่เพียงแนะนำรายการเมนูเท่านั้น แต่ยังสร้างคำอธิบาย รายการสารก่อภูมิแพ้ และอื่นๆ ด้วย)
  • ยืนยันว่าเอาต์พุตเป็นไปตามสคีมา
  • จัดระเบียบเอาต์พุตของโมเดลเป็นประเภท Go

หากต้องการรับเอาต์พุตที่มีโครงสร้างจากการเรียกใช้ generate ที่สำเร็จ ให้เรียกใช้ Output() ในการตอบกลับของรูปแบบที่มีค่าว่างของประเภทต่อไปนี้

var item MenuItem
if err := resp.Output(&item); err != nil {
    log.Fatalf(err)
}

log.Printf("%s (%d calories, %d allergens): %s\n",
    item.Name, item.Calories, len(item.Allergens), item.Description)

หรือจะใช้ genkit.GenerateData() เพื่อเรียกใช้คำสั่งสั้นๆ ก็ได้

item, resp, err := genkit.GenerateData[MenuItem](ctx, g,
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)
if err != nil {
  log.Fatal(err)
}

log.Printf("%s (%d calories, %d allergens): %s\n",
    item.Name, item.Calories, len(item.Allergens), item.Description)

ฟังก์ชันนี้ต้องใช้พารามิเตอร์ประเภทเอาต์พุต แต่จะตั้งค่าตัวเลือก WithOutputType() และเรียกใช้ resp.Output() โดยอัตโนมัติก่อนที่จะแสดงผลค่า

การจัดการข้อผิดพลาด

โปรดทราบว่าในตัวอย่างก่อนหน้านี้การเรียก genkit.Generate() อาจทำให้เกิดข้อผิดพลาด ข้อผิดพลาดที่อาจเกิดขึ้นได้อย่างหนึ่งคือเมื่อโมเดลสร้างเอาต์พุตที่เป็นไปตามสคีมาไม่ได้ กลยุทธ์ที่ดีที่สุดในการจัดการกับข้อผิดพลาดดังกล่าวจะขึ้นอยู่กับกรณีการใช้งานของคุณ แต่เคล็ดลับทั่วไปมีดังนี้

  • ลองใช้อุปกรณ์รุ่นอื่น โมเดลต้องสร้างเอาต์พุตในรูปแบบ JSON ได้จึงจะสร้าง Structured Data ได้อย่างสมบูรณ์ LLM ที่มีประสิทธิภาพมากที่สุดอย่าง Gemini นั้นมีความอเนกประสงค์มากพอที่จะทําเช่นนี้ได้ แต่โมเดลขนาดเล็ก เช่น โมเดลในเครื่องบางรายการที่คุณจะใช้กับ Ollama อาจสร้างเอาต์พุตที่มีโครงสร้างได้อย่างไม่น่าเชื่อถือ เว้นแต่จะได้รับการฝึกมาโดยเฉพาะ

  • ลดความซับซ้อนของสคีมา LLM อาจมีปัญหาในการสร้างประเภทที่ซับซ้อนหรือฝังลึก ลองใช้ชื่อที่ชัดเจน ฟิลด์ที่น้อยลง หรือโครงสร้างแบบแบนหากสร้าง Structured Data ไม่ได้

  • ลองโทรหา genkit.Generate() อีกครั้ง หากโมเดลที่คุณเลือกสร้างเอาต์พุตที่เป็นไปตามข้อกำหนดได้เพียงนานๆ ครั้ง คุณอาจจัดการกับข้อผิดพลาดนี้เหมือนกับจัดการกับข้อผิดพลาดของเครือข่าย และลองส่งคำขออีกครั้งโดยใช้กลยุทธ์การลดระดับแบบค่อยเป็นค่อยไป

อุปกรณ์การสตรีม

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

ใน Genkit คุณสามารถสตรีมเอาต์พุตได้โดยใช้ตัวเลือก WithStreaming() ดังนี้

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("Suggest a complete menu for a pirate themed restaurant."),
    ai.WithStreaming(func(ctx context.Context, chunk *ai.ModelResponseChunk) error {
        // Do something with the chunk...
        log.Println(chunk.Text())
        return nil
    }),
)
if err != nil {
    log.Fatal(err)
}

log.Println(resp.Text())

อินพุตหลายรูปแบบ

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

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

หากต้องการระบุพรอมต์สื่อให้กับโมเดลที่รองรับ ให้ส่งอาร์เรย์ที่มีส่วนสื่อและส่วนข้อความแทนการส่งพรอมต์ข้อความธรรมดาไปยัง genkit.Generate() ตัวอย่างนี้ระบุรูปภาพโดยใช้ HTTPS URL ที่เข้าถึงได้แบบสาธารณะ

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.0-flash"),
    ai.WithMessages(
        NewUserMessage(
            NewMediaPart("image/jpeg", "https://example.com/photo.jpg"),
            NewTextPart("Compose a poem about this image."),
        ),
    ),
)

นอกจากนี้ คุณยังส่งข้อมูลสื่อได้โดยตรงด้วยการเข้ารหัสเป็น URL ข้อมูล เช่น

image, err := ioutil.ReadFile("photo.jpg")
if err != nil {
    log.Fatal(err)
}

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.0-flash"),
    ai.WithMessages(
        NewUserMessage(
            NewMediaPart("image/jpeg", "data:image/jpeg;base64," + base64.StdEncoding.EncodeToString(image)),
            NewTextPart("Compose a poem about this image."),
        ),
    ),
)

โมเดลทั้งหมดที่รองรับอินพุตสื่อจะรองรับทั้ง URL ข้อมูลและ URL HTTPS ส่วนปลั๊กอินบางรุ่นจะรองรับแหล่งที่มาของสื่ออื่นๆ ด้วย เช่น ปลั๊กอิน Vertex AI ยังให้คุณใช้ URL ของ Cloud Storage (gs://) ได้ด้วย

ขั้นตอนถัดไป

ดูข้อมูลเพิ่มเติมเกี่ยวกับ Genkit

  • ในฐานะนักพัฒนาแอป วิธีหลักที่คุณส่งผลต่อเอาต์พุตของโมเดล Generative AI คือการใช้พรอมต์ อ่านหัวข้อการจัดการพรอมต์ด้วย Dotprompt เพื่อดูว่า Genkit ช่วยคุณพัฒนาพรอมต์ที่มีประสิทธิภาพและจัดการพรอมต์ในโค้ดเบสได้อย่างไร
  • แม้ว่า genkit.Generate() จะเป็นหัวใจสำคัญของแอปพลิเคชันทุกแอปพลิเคชันที่ทำงานด้วย Generative AI แต่แอปพลิเคชันในชีวิตจริงมักจะต้องมีการดำเนินการเพิ่มเติมก่อนและหลังการเรียกใช้โมเดล Generative AI Genkit จึงนําเสนอแนวคิดโฟลว์ ซึ่งกําหนดไว้เหมือนฟังก์ชัน แต่เพิ่มฟีเจอร์อื่นๆ เช่น การสังเกตการณ์และการปรับใช้งานที่ง่ายขึ้น ดูข้อมูลเพิ่มเติมได้ที่การกําหนดเวิร์กโฟลว์ AI

การใช้งาน LLM ขั้นสูง

แอปของคุณสามารถใช้เทคนิคต่างๆ เพื่อรับประโยชน์จาก LLM ได้มากขึ้น

  • วิธีหนึ่งในการปรับปรุงความสามารถของ LLM คือการแสดงรายการวิธีที่ LLM สามารถขอข้อมูลเพิ่มเติมจากคุณ หรือขอให้คุณดำเนินการบางอย่าง การดำเนินการนี้เรียกว่าการเรียกใช้เครื่องมือหรือการเรียกใช้ฟังก์ชัน โมเดลที่ได้รับการฝึกให้รองรับความสามารถนี้จะตอบสนองต่อพรอมต์ด้วยการตอบกลับที่มีการจัดรูปแบบเป็นพิเศษ ซึ่งจะบ่งบอกให้แอปพลิเคชันที่เรียกใช้ทราบว่าควรดำเนินการบางอย่างและส่งผลลัพธ์กลับไปยัง LLM พร้อมกับพรอมต์เดิม Genkit มีฟังก์ชันไลบรารีที่ทําทั้งการสร้างพรอมต์และองค์ประกอบลูปการเรียกใช้การตอบกลับของการใช้งานการเรียกใช้เครื่องมือโดยอัตโนมัติ ดูข้อมูลเพิ่มเติมได้ที่การเรียกใช้เครื่องมือ
  • การสร้างที่เพิ่มการดึงข้อมูล (RAG) เป็นเทคนิคที่ใช้เพื่อนำข้อมูลเฉพาะโดเมนมาใส่ไว้ในเอาต์พุตของโมเดล ซึ่งทำได้โดยการแทรกข้อมูลที่เกี่ยวข้องลงในพรอมต์ก่อนที่จะส่งต่อไปยังโมเดลภาษา การใช้งาน RAG อย่างสมบูรณ์ต้องใช้เทคโนโลยีหลายอย่างร่วมกัน ได้แก่ โมเดลการสร้างการฝังข้อความ ฐานข้อมูลเวกเตอร์ และโมเดลภาษาขนาดใหญ่ ดูการสร้างที่เพิ่มการดึงข้อมูล (RAG) เพื่อดูวิธีที่ Genkit ลดความซับซ้อนของกระบวนการประสานองค์ประกอบต่างๆ เหล่านี้