Genkit for Node.js 1.0 is now available and production-ready! Learn more

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

การประเมิน

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

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

ประเภทการประเมิน

Genkit รองรับการประเมิน 2 ประเภท ได้แก่

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

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

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

ดูข้อมูลเพิ่มเติมได้ที่ส่วนการใช้งานขั้นสูงของหน้านี้

ส่วนนี้จะอธิบายวิธีทําการประเมินที่อิงตามการอนุมานโดยใช้ Genkit

คู่มือเริ่มใช้งานฉบับย่อ

ตั้งค่า

ใช้แอป Genkit ที่มีอยู่หรือสร้างแอปใหม่โดยทำตามคู่มือ [เริ่มต้นใช้งาน](get-started.md)

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

import { genkit, z, Document } from "genkit";
import {
  googleAI,
  gemini15Flash,
} from "@genkit-ai/googleai";

// Initialize Genkit
export const ai = genkit ({
  plugins: [
    googleAI(),
  ]
});

// Dummy retriever that always returns the same docs
export const dummyRetriever = ai.defineRetriever(
  {
    name: "dummyRetriever",
  },
  async (i) => {
    const facts = [
      "Dog is man's best friend", 
      "Dogs have evolved and were domesticated from wolves",
    ];
    // Just return facts as documents.
    return { documents: facts.map((t) => Document.fromText(t)) };
  }
);

// A simple question-answering flow
export const qaFlow = ai.defineFlow({
    name: 'qaFlow',
    inputSchema: z.string(),
    outputSchema: z.string(),
  },
  async (query) => {
    const factDocs = await ai.retrieve({
      retriever: dummyRetriever,
      query,
    });

    const llmResponse = await ai.generate({
      model: gemini15Flash,
      prompt: `Answer this question with the given context ${query}`,
      docs: factDocs,
    });
    return llmResponse.text;
  }
);

(ไม่บังคับ) เพิ่มเมตริกการประเมินลงในแอปพลิเคชันเพื่อใช้ขณะประเมิน คู่มือนี้ใช้เมตริก MALICIOUSNESS จากปลั๊กอิน genkitEval
```
import { genkitEval, GenkitMetric } from "@genkit-ai/evaluator";
import { gemini15Pro } from "@genkit-ai/googleai";

export const ai = genkit ({
  plugins: [
    ...
    // Add this plugin to your Genkit initialization block
    genkitEval({
      judge: gemini15Pro,
      metrics: [GenkitMetric.MALICIOUSNESS],
    }),
  ]
});
```
หมายเหตุ: การกําหนดค่าข้างต้นจําเป็นต้องติดตั้งแพ็กเกจ @genkit-ai/evaluator
```
npm install @genkit-ai/evaluator
```
เริ่มแอปพลิเคชัน Genkit
```
genkit start -- 
```

สร้างชุดข้อมูล

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

ไปที่ UI ของนักพัฒนาซอฟต์แวร์ที่ http://localhost:4000 แล้วคลิกปุ่มชุดข้อมูลเพื่อเปิดหน้าชุดข้อมูล
คลิกปุ่มสร้างชุดข้อมูลเพื่อเปิดกล่องโต้ตอบสร้างชุดข้อมูล

ก. ระบุ datasetId สำหรับชุดข้อมูลใหม่ คู่มือนี้ใช้ myFactsQaDataset

ข. เลือกประเภทชุดข้อมูล Flow

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

ก. คลิกปุ่มเพิ่มตัวอย่างเพื่อเปิดแผงเครื่องมือแก้ไขตัวอย่าง

ข. เฉพาะช่อง input เท่านั้นที่ต้องกรอก ป้อน "Who is man's best friend?" ในช่อง input แล้วคลิกบันทึกเพื่อเพิ่มตัวอย่างลงในชุดข้อมูล

ค. ทำขั้นตอน (ก) และ (ข) ซ้ำอีก 2-3 ครั้งเพื่อเพิ่มตัวอย่าง คู่มือนี้จะเพิ่มอินพุตตัวอย่างต่อไปนี้ลงในชุดข้อมูล
```
"Can I give milk to my cats?"
"From which animals did dogs evolve?"
```
เมื่อสิ้นสุดขั้นตอนนี้ ชุดข้อมูลของคุณควรมีตัวอย่าง 3 รายการพร้อมค่าที่กล่าวถึงข้างต้น

เรียกใช้การประเมินและดูผลลัพธ์

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

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

คุณดูรายละเอียดของการประเมินได้ในหน้านี้ ซึ่งรวมถึงอินพุตต้นฉบับ บริบทที่ดึงมา และเมตริก (หากมี)

แนวคิดหลัก

คำศัพท์

การประเมิน: การประเมินเป็นกระบวนการที่ประเมินประสิทธิภาพของระบบ ใน Genkit ระบบดังกล่าวมักจะเป็น Genkit Primitive เช่น ฟีดหรือรูปแบบ การประเมินอาจเป็นแบบอัตโนมัติหรือแบบดำเนินการด้วยตนเอง (การประเมินโดยเจ้าหน้าที่)
การอนุมานแบบเป็นกลุ่ม การอนุมานคือการเรียกใช้อินพุตในเวิร์กโฟลว์หรือโมเดลเพื่อรับเอาต์พุตที่เกี่ยวข้อง การอนุมานแบบเป็นกลุ่มเกี่ยวข้องกับการอนุมานอินพุตหลายรายการพร้อมกัน
เมตริก เมตริกการประเมินคือเกณฑ์ที่ใช้ให้คะแนนการอนุมาน เช่น ความถูกต้อง ความซื่อสัตย์ ความเป็นอันตราย ผลลัพธ์เป็นภาษาอังกฤษหรือไม่ ฯลฯ
ชุดข้อมูล ชุดข้อมูลคือคอลเล็กชันตัวอย่างที่จะใช้ประเมินตามการอนุมาน โดยปกติแล้วชุดข้อมูลจะประกอบด้วยฟิลด์ input และ reference (ไม่บังคับ) ช่อง reference จะไม่ส่งผลต่อขั้นตอนการอนุมานของการประเมิน แต่ระบบจะส่งค่านี้ไปยังเมตริกการประเมินทุกรายการตามตัวอักษร ใน Genkit คุณสามารถสร้างชุดข้อมูลผ่าน UI สําหรับนักพัฒนาซอฟต์แวร์ได้ ชุดข้อมูลใน Genkit มี 2 ประเภท ได้แก่ ชุดข้อมูลโฟลว์และชุดข้อมูลโมเดล

การตรวจสอบสคีมา

ชุดข้อมูลรองรับการตรวจสอบสคีมาใน UI สําหรับนักพัฒนาซอฟต์แวร์ โดยขึ้นอยู่กับประเภทดังนี้

ชุดข้อมูลโฟลว์รองรับการตรวจสอบความถูกต้องของช่อง input และ reference ของชุดข้อมูลเทียบกับโฟลว์ในแอปพลิเคชัน Genkit การตรวจสอบสคีมาเป็นตัวเลือก และจะบังคับใช้ก็ต่อเมื่อมีระบุสคีมาในเวิร์กโฟลว์เป้าหมายเท่านั้น
ชุดข้อมูลโมเดลมีสคีมาโดยนัย ซึ่งรองรับทั้งประเภทอินพุต string และ GenerateRequest การตรวจสอบสตริงเป็นวิธีที่สะดวกในการประเมินพรอมต์ข้อความแบบง่าย ขณะที่ GenerateRequest ให้การควบคุมที่สมบูรณ์สำหรับ Use Case ขั้นสูง (เช่น การให้พารามิเตอร์ของโมเดล ประวัติข้อความ เครื่องมือ ฯลฯ) คุณดูสคีมาแบบเต็มของ GenerateRequest ได้ในเอกสารอ้างอิง API

ผู้ประเมินที่รองรับ

ผู้ประเมิน Genkit

Genkit มีเครื่องมือประเมินแบบเนทีฟจำนวนไม่มากนักซึ่งได้รับแรงบันดาลใจจาก RAGAS เพื่อช่วยคุณเริ่มต้นใช้งาน

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

ปลั๊กอินเครื่องมือประเมิน

Genkit รองรับเครื่องมือประเมินเพิ่มเติมผ่านปลั๊กอิน เช่น Vertex Rapid evaluator ซึ่งเข้าถึงได้ผ่านปลั๊กอิน VertexAI

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

การประเมินโดยใช้ CLI

Genkit CLI มี API ที่สมบูรณ์สำหรับการดำเนินการประเมิน ซึ่งจะเป็นประโยชน์อย่างยิ่งในสภาพแวดล้อมที่ไม่มี UI ของนักพัฒนาซอฟต์แวร์ (เช่น ในเวิร์กโฟลว์ CI/CD)

Genkit CLI มีคำสั่งการประเมินหลัก 3 รายการ ได้แก่ eval:flow, eval:extractData และeval:run

คำสั่ง `eval:flow`

คำสั่ง eval:flow จะเรียกใช้การประเมินที่อิงตามการอนุมานในชุดข้อมูลอินพุต ชุดข้อมูลนี้อาจอยู่ในรูปแบบไฟล์ JSON หรืออ้างอิงชุดข้อมูลที่มีอยู่ในการรันไทม์ Genkit

# Referencing an existing dataset
genkit eval:flow qaFlow --input myFactsQaDataset
# or, using a dataset from a file
genkit eval:flow qaFlow --input testInputs.json

ในที่นี้ testInputs.json ควรเป็นอาร์เรย์ของออบเจ็กต์ที่มีช่อง input และช่อง reference ที่ไม่บังคับ ดังตัวอย่างด้านล่าง

[
  {
    "input": "What is the French word for Cheese?",
  },
  {
    "input": "What green vegetable looks like cauliflower?",
    "reference": "Broccoli"
  }
]

หากขั้นตอนของคุณต้องใช้การตรวจสอบสิทธิ์ คุณสามารถระบุการตรวจสอบสิทธิ์ได้โดยใช้อาร์กิวเมนต์ --context ดังนี้

genkit eval:flow qaFlow --input testInputs.json --context '{"auth": {"email_verified": true}}'

โดยค่าเริ่มต้น คำสั่ง eval:flow และ eval:run จะใช้เมตริกทั้งหมดที่มีอยู่เพื่อประเมิน หากต้องการเรียกใช้กับชุดย่อยของเครื่องมือประเมินที่กําหนดค่าไว้ ให้ใช้ Flag --evaluators และระบุรายการเครื่องมือประเมินที่คั่นด้วยคอมมาตามชื่อ

genkit eval:flow qaFlow --input testInputs.json --evaluators=genkitEval/maliciousness,genkitEval/answer_relevancy

คุณดูผลลัพธ์ของการเรียกใช้การประเมินได้ใน UI ของนักพัฒนาซอฟต์แวร์ ที่ localhost:4000/evaluate

คำสั่ง `eval:extractData` และ `eval:run`

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

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

เรียกใช้ขั้นตอนกับอินพุตทดสอบ

genkit flow:batchRun qaFlow testInputs.json --label firstRunSimple

ดึงข้อมูลการประเมิน

genkit eval:extractData qaFlow --label firstRunSimple --output factsEvalDataset.json

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

Array<{
  "testCaseId": string,
  "input": any,
  "output": any,
  "context": any[],
  "traceIds": string[],
}>;

เครื่องมือดึงข้อมูลจะค้นหาเครื่องมือดึงข้อมูลโดยอัตโนมัติและเพิ่มเอกสารที่สร้างขึ้นลงในอาร์เรย์บริบท คุณสามารถเรียกใช้เมตริกการประเมินในชุดข้อมูลที่ดึงข้อมูลนี้โดยใช้คําสั่ง eval:run

genkit eval:run factsEvalDataset.json

โดยค่าเริ่มต้น eval:run จะทํางานกับเครื่องมือประเมินที่กําหนดค่าไว้ทั้งหมด และเช่นเดียวกับ eval:flow ผลลัพธ์ของ eval:run จะปรากฏในหน้าการประเมินของ Developer UI ซึ่งอยู่ที่ localhost:4000/evaluate

เครื่องมือแยกข้อมูลที่กำหนดเอง

Genkit มีตรรกะเริ่มต้นที่เหมาะสมในการดึงข้อมูลช่องที่จําเป็น (input, output และ context) ขณะประเมิน อย่างไรก็ตาม คุณอาจพบว่าต้องการควบคุมตรรกะการดึงข้อมูลสําหรับช่องเหล่านี้มากขึ้น Genkit รองรับเครื่องมือแยกข้อมูลที่กำหนดเองเพื่อให้บรรลุเป้าหมายนี้ คุณสามารถระบุเครื่องมือดึงข้อมูลที่กำหนดเองเพื่อใช้ในคำสั่ง eval:extractData และ eval:flow

ก่อนอื่น เพื่อเป็นการเตรียมความพร้อม ให้แนะนำขั้นตอนเสริมในqaFlowตัวอย่างของเรา ดังนี้

export const qaFlow = ai.defineFlow({
    name: 'qaFlow',
    inputSchema: z.string(),
    outputSchema: z.string(),
  },
  async (query) => {
    const factDocs = await ai.retrieve({
      retriever: dummyRetriever,
      query,
    });
    const factDocsModified = await ai.run('factModified', async () => {
        // Let us use only facts that are considered silly. This is a 
        // hypothetical step for demo purposes, you may perform any 
        // arbitrary task inside a step and reference it in custom 
        // extractors.
        //
        // Assume you have a method that checks if a fact is silly
        return factDocs.filter(d => isSillyFact(d.text));
    });

    const llmResponse = await ai.generate({
      model: gemini15Flash,
      prompt: `Answer this question with the given context ${query}`,
      docs: factDocsModified,
    });
    return llmResponse.text;
  }
);

ถัดไป ให้กําหนดค่าเครื่องมือแยกข้อมูลที่กำหนดเองเพื่อใช้เอาต์พุตของfactModifiedขั้นตอน เมื่อประเมินขั้นตอนนี้

หากไม่มีไฟล์ tools-config เพื่อกําหนดค่าเครื่องมือแยกข้อมูลที่กำหนดเอง ให้เพิ่มไฟล์ชื่อ genkit-tools.conf.js ลงในรูทโปรเจ็กต์

cd /path/to/your/genkit/app
touch genkit-tools.conf.js

ในไฟล์การกําหนดค่าเครื่องมือ ให้เพิ่มโค้ดต่อไปนี้

module.exports = {
  evaluators: [
    {
      actionRef: '/flow/qaFlow',
      extractors: {
        context: { outputOf: 'factModified' },
      },
    },
  ],
};

การกําหนดค่านี้จะลบล้างเครื่องมือดึงข้อมูลเริ่มต้นของ Genkit โดยเฉพาะการเปลี่ยนแปลงสิ่งที่ถือว่าเป็น context เมื่อประเมินขั้นตอนนี้

การประเมินอีกครั้งแสดงให้เห็นว่าตอนนี้ระบบป้อนข้อมูลบริบทเป็นเอาต์พุตของขั้นตอน factModified แล้ว

genkit eval:flow qaFlow --input testInputs.json

ระบุเครื่องมือดึงข้อมูลการประเมินดังนี้

ฟิลด์ evaluators ยอมรับอาร์เรย์ของออบเจ็กต์ EvaluatorConfig ซึ่งอยู่ภายใต้ขอบเขตของ flowName
extractors คือออบเจ็กต์ที่ระบุการลบล้างข้อมูลที่ใช้ดึงข้อมูล คีย์ที่รองรับในปัจจุบันใน extractors คือ [input, output, context] ประเภทค่าที่ยอมรับได้มีดังนี้
- string - ควรเป็นชื่อขั้นตอนที่ระบุเป็นสตริง ระบบจะดึงข้อมูลเอาต์พุตของขั้นตอนนี้สำหรับคีย์นี้
- { inputOf: string } หรือ { outputOf: string } - ออบเจ็กต์เหล่านี้แสดงถึงแชแนลที่เฉพาะเจาะจง (อินพุตหรือเอาต์พุต) ของขั้นตอน เช่น { inputOf: 'foo-step' } จะดึงข้อมูลของขั้นตอน foo-step สำหรับคีย์นี้
- (trace) => string; - หากต้องการความยืดหยุ่นมากขึ้น คุณสามารถระบุฟังก์ชันที่ยอมรับการติดตาม Genkit และแสดงผลค่าประเภท any รวมถึงระบุตรรกะการดึงข้อมูลภายในฟังก์ชันนี้ได้ ดูสคีมา TraceData ที่แน่นอนได้ที่ genkit/genkit-tools/common/src/types/trace.ts

หมายเหตุ: ข้อมูลที่ดึงมาสำหรับเครื่องมือดึงข้อมูลทั้งหมดเหล่านี้จะเป็นประเภทที่สอดคล้องกับเครื่องมือดึงข้อมูล เช่น หากคุณใช้ context: { outputOf: 'foo-step' } และ foo-step แสดงผลอาร์เรย์ออบเจ็กต์ บริบทที่ดึงมาก็จะเป็นอาร์เรย์ออบเจ็กต์เช่นกัน

การสังเคราะห์ข้อมูลทดสอบโดยใช้ LLM

ต่อไปนี้คือตัวอย่างขั้นตอนที่ใช้ไฟล์ PDF เพื่อสร้างคำถามที่ผู้ใช้อาจถาม

import { genkit, z } from "genkit";
import { googleAI, gemini15Flash } from "@genkit-ai/googleai";
import { chunk } from "llm-chunk"; // npm i llm-chunk
import path from "path";
import { readFile } from "fs/promises";
import pdf from "pdf-parse"; // npm i pdf-parse

const ai = genkit({ plugins: [googleAI()] });

const chunkingConfig = {
  minLength: 1000, // number of minimum characters into chunk
  maxLength: 2000, // number of maximum characters into chunk
  splitter: "sentence", // paragraph | sentence
  overlap: 100, // number of overlap chracters
  delimiters: "", // regex for base split method
} as any;

async function extractText(filePath: string) {
  const pdfFile = path.resolve(filePath);
  const dataBuffer = await readFile(pdfFile);
  const data = await pdf(dataBuffer);
  return data.text;
}

export const synthesizeQuestions = ai.defineFlow(
  {
    name: "synthesizeQuestions",
    inputSchema: z.string().describe("PDF file path"),
    outputSchema: z.array(z.string()),
  },
  async (filePath) => {
    filePath = path.resolve(filePath);
    // `extractText` loads the PDF and extracts its contents as text.
    const pdfTxt = await ai.run("extract-text", () => extractText(filePath));

    const chunks = await ai.run("chunk-it", async () =>
      chunk(pdfTxt, chunkingConfig)
    );

    const questions: string[] = [];
    for (var i = 0; i < chunks.length; i++) {
      const qResponse = await ai.generate({
        model: gemini15Flash,
        prompt: {
          text: `Generate one question about the text below: ${chunks[i]}`,
        },
      });
      questions.push(qResponse.text);
    }
    return questions;
  }
);

จากนั้นใช้คําสั่งนี้เพื่อส่งออกข้อมูลไปยังไฟล์และใช้เพื่อประเมิน

genkit flow:run synthesizeQuestions '"my_input.pdf"' --output synthesizedQuestions.json