การเรียกใช้เครื่องมือ

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

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

การให้สิทธิ์ LLM เข้าถึงข้อมูลที่ไม่ได้รับการฝึก

• ข้อมูลที่เปลี่ยนแปลงบ่อย เช่น เมนูประจำวันของร้านอาหาร หรือ สถานะสินค้าคงคลังของร้านค้า
• ข้อมูลเฉพาะสำหรับโดเมนแอปของคุณ เช่น ข้อมูลผลิตภัณฑ์

โปรดทราบความคาบเกี่ยวกันกับ Retrieval Augmented Generation (RAG) ซึ่งเป็น วิธีที่ทำให้ LLM รวมข้อมูลข้อเท็จจริงเข้ากับคนรุ่นหลังได้ RAG คือ โซลูชันที่หนักกว่าซึ่งเหมาะสมที่สุดเมื่อคุณมี หรือข้อมูลที่เกี่ยวข้องกับพรอมต์มากที่สุดนั้นไม่ชัดเจน เปิด ในทางกลับกัน หากการดึงข้อมูลที่ LLM ต้องการเป็นฟังก์ชันที่เรียบง่าย การโทรหรือการค้นหาฐานข้อมูล การเรียกเครื่องมือจะเหมาะสมกว่า

ขอแนะนำการทำงานแบบกำหนดระดับขั้นในเวิร์กโฟลว์ LLM

• การคำนวณที่ LLM ไม่สามารถสร้างด้วยตัวเองได้อย่างน่าเชื่อถือ
• การบังคับให้ LLM สร้างข้อความแบบคำต่อคำภายใต้สถานการณ์บางอย่าง เช่น เมื่อตอบคำถามเกี่ยวกับข้อกำหนดในการให้บริการของแอป

การดำเนินการเมื่อดำเนินการโดย LLM

• การเปิดและปิดไฟในผู้ช่วยในบ้านที่ทำงานด้วยระบบ LLM
• จองโต๊ะในตัวแทนร้านอาหารที่ทำงานด้วยระบบ LLM

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

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

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

ภาพรวมของการเรียกใช้เครื่องมือ

ในระดับสูง นี่คือการโต้ตอบการเรียกใช้เครื่องมือกับ LLM โดยทั่วไป ดูเหมือน:

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

เพื่อให้เป็นไปได้ ต้องปฏิบัติตามข้อกำหนดหลายประการดังนี้

• โมเดลต้องได้รับการฝึกให้ส่งคำขอเครื่องมือเมื่อจำเป็น ปรากฏขึ้น โมเดลขนาดใหญ่ส่วนใหญ่ที่ให้บริการผ่าน API ของเว็บ เช่น Gemini และ Claude ก็สามารถทำได้ แต่โมเดลที่เล็กกว่าและพิเศษกว่ามักจะทำไม่ได้ Genkit จะแสดงข้อผิดพลาดหากคุณพยายามจัดหาเครื่องมือให้แก่โมเดลที่ไม่มี ก็สนับสนุนได้เลย
• แอปพลิเคชันการเรียกใช้ต้องมีคำจำกัดความเครื่องมือให้กับโมเดลใน ตามที่คาดหวังไว้
• แอปพลิเคชันการเรียกใช้ต้องแจ้งให้โมเดลสร้างการเรียกใช้เครื่องมือ คำขอในรูปแบบที่แอปพลิเคชันต้องการ

การเรียกใช้เครื่องมือด้วย Genkit

Genkit มีอินเทอร์เฟซเพียงแบบเดียวสำหรับการเรียกเครื่องมือจากรุ่นที่รองรับ ปลั๊กอินโมเดลแต่ละตัวช่วยให้มั่นใจได้ว่า 2 เกณฑ์สุดท้ายจากที่กล่าวมาข้างต้น และ ฟังก์ชัน generate() จะดำเนินการวนซ้ำการเรียกเครื่องมือโดยอัตโนมัติ ที่อธิบายก่อนหน้านี้

การรองรับโมเดล

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

• Genkit จะแสดงข้อผิดพลาดหากคุณพยายามจัดหาเครื่องมือให้แก่โมเดลที่ไม่มี ก็สนับสนุนได้เลย
• หากปลั๊กอินส่งออกการอ้างอิงโมเดล พร็อพเพอร์ตี้ info.supports.tools จะระบุว่ารองรับการเรียกใช้เครื่องมือหรือไม่

การกำหนดเครื่องมือ

ใช้ฟังก์ชัน defineTool() เพื่อเขียนคำจำกัดความของเครื่องมือ

const specialToolInputSchema = z.object({ meal: z.enum(["breakfast", "lunch", "dinner"]) });
const specialTool = defineTool(
  {
    name: "specialTool",
    description: "Retrieves today's special for the given meal",
    inputSchema: specialToolInputSchema,
    outputSchema: z.string(),
  },
  async ({ meal }): Promise<string> => {
    // Retrieve up-to-date information and return it. Here, we just return a
    // fixed value.
    return "Baked beans on toast";
  }
);

ไวยากรณ์ในส่วนนี้มีลักษณะเหมือนกับไวยากรณ์ defineFlow() แต่ทั้ง 4 อย่าง พารามิเตอร์ name, description, inputSchema และ outputSchema ต้องระบุ เมื่อเขียนคำจำกัดความของเครื่องมือ โปรดระมัดระวังการใช้คำและ รายละเอียดของพารามิเตอร์เหล่านี้ เนื่องจากพารามิเตอร์ดังกล่าวมีความสำคัญต่อ LLM ในการ ใช้ประโยชน์จากเครื่องมือที่มีอยู่ได้อย่างมีประสิทธิภาพ

รวมถึงเครื่องมือในพรอมต์ของคุณ

หลังจากที่คุณกำหนดเครื่องมือแล้ว ให้ระบุเครื่องมือในพารามิเตอร์เครื่องมือของ generate():

const llmResponse = await generate({
  model: gemini15Flash,
  prompt,
  tools: [specialTool],
});

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

การจัดการการเรียกเครื่องมืออย่างชัดแจ้ง

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

let generateOptions: GenerateOptions = {
  model: gemini15Flash,
  prompt,
  tools: [specialTool],
  returnToolRequests: true,
};
let llmResponse;
while (true) {
  llmResponse = await generate(generateOptions);
  const toolRequests = llmResponse.toolRequests();
  if (toolRequests.length < 1) {
    break;
  }
  const toolResponses: ToolResponsePart[] = await Promise.all(
    toolRequests.map(async (part) => {
      switch (part.toolRequest.name) {
        case "specialTool":
          return {
            toolResponse: {
              name: part.toolRequest.name,
              ref: part.toolRequest.ref,
              output: await specialTool(specialToolInputSchema.parse(part.toolRequest?.input)),
            },
          };
        default:
          throw Error('Tool not found');
        }
      }));
    generateOptions.history = llmResponse.toHistory();
    generateOptions.prompt = toolResponses;
}