ข้ามไปยังเนื้อหาหลัก

LangChain.js และ Oracle AI Database: คู่มือการค้นหาด้วยเวกเตอร์

เชื่อมต่อ LangChain.js กับ Oracle AI Database ด้วย OracleVS จัดเก็บ embeddings พร้อมเมทาดาทา และเปรียบเทียบ similarity search ตัวกรองเมทาดาทา และ MMR ใน TypeScript
· 10 นาที อ่าน

สำรวจด้วย AI

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

Oracle AI Database เติมเต็มบทบาทนั้นผ่านการเชื่อมต่อ @oracle/langchain-oracledb ในคู่มือนี้ จะเชื่อมเวิร์กโฟลว์ TypeScript ขนาดเล็กเข้ากับ Oracle จัดเก็บข้อความพร้อมเมทาดาทา เรียกใช้การค้นหาความคล้ายคลึง และปรับปรุงการดึงข้อมูลด้วยตัวกรองและ Maximal Marginal Relevance (MMR) บทเรียนนี้เน้นเวิร์กโฟลว์การดึงข้อมูล; แอปพลิเคชัน TypeScript คู่กันเพิ่มการเชื่อมต่อเดียวกันให้กับ UI เบราว์เซอร์แบบโต้ตอบ

สำหรับรายละเอียดการเชื่อมต่อ โปรดดู คู่มือการเชื่อมต่อ Oracle LangChain JavaScript อย่างเป็นทางการ.

การผสาน LangChain.js และ Oracle AI Database คืออะไร?

LangChain.js ทำให้การทำงานกับโมเดลสร้าง embeddings และคลังเก็บเวกเตอร์มีมาตรฐาน แพ็กเกจการเชื่อมต่อของ Oracle จัดเตรียม OracleVS ซึ่งเป็นการติดตั้ง vector store ที่เก็บข้อความเอกสาร เมทาดาทา และเวกเตอร์ embeddings ไว้ใน Oracle AI Database แอปพลิเคชันจึงเรียกเมธอดของ LangChain.js แทนการเขียน SQL เองสำหรับทุกคิวรีแบบ similarity

แพ็กเกจเดียวกันยังมี OracleDocLoader, OracleTextSplitter, OracleEmbeddings และ OracleSummary ซึ่งเป็นบล็อกประกอบเสริมที่มีประโยชน์; ตัวอย่างด้านล่างมุ่งที่ OracleVS และแยกการสร้าง embeddings ออกเพื่อให้ขั้นตอนเข้าใจง่าย

แผนภาพสถาปัตยกรรมแสดงเวิร์กโฟลว์ RAG ของ LangChain.js ใน TypeScript: React UI ส่งคำถามไปยัง Node.js API, LangChain.js สร้าง embeddings และดึงเอกสารผ่าน OracleVS จากตารางเวกเตอร์ใน Oracle AI Database และ API ส่งคำตอบที่อ้างอิงหลักฐานกลับมา

การนำเอกสารเข้าและการดึงข้อมูลด้วย LangChain.js, OracleVS และ Oracle AI Database

คุณสมบัติเด่นของการผสาน

จัดเก็บ embeddings คู่กับเมทาดาทาของเอกสาร

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

ดึงข้อความที่เกี่ยวข้องด้วยความคล้ายคลึงของเวกเตอร์

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

ควบคุมผลลัพธ์ด้วยการกรองและ MMR

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

เริ่มต้นใช้งาน LangChain.js และ Oracle AI Database

สิ่งที่ต้องเตรียม

สำหรับตัวอย่าง TypeScript นี้ ต้องใช้ Node.js 24.13.0, npm 11.6.2, Oracle AI Database 26ai Free แบบโลคอลที่รองรับเวกเตอร์ และสคีมาที่สามารถสร้าง แทรก คิวรี และดรอปตารางสาธิตรวมถึงดัชนีเวกเตอร์ได้ นอกจากนี้ต้องมีคีย์ OpenAI API สำหรับตัวอย่าง embedding ด้วย OpenAIEmbeddings เป็นตัวเลือกที่เข้ากันกับ LangChain ไม่ใช่ข้อบังคับของ OracleVS

ติดตั้ง Node.js จาก หน้าดาวน์โหลดอย่างเป็นทางการของ Node.js

สำหรับวิธีหลักแบบโลคอล ให้ทำตาม Quick Start ของ Oracle AI Database Free หลังจากฐานข้อมูลทำงานแล้ว ให้ใช้บริการ เช่น localhost:1521/FREEPDB1 และสคีมาที่มีสิทธิ์ตามที่ระบุไว้ข้างต้น

สร้างโปรเจกต์ TypeScript

mkdir langchain-oracle-demo
cd langchain-oracle-demo
npm init -y
npm pkg set type=module
npm install @oracle/[email protected] @langchain/[email protected] @langchain/[email protected] [email protected] [email protected]
npm install --save-dev [email protected] [email protected] @types/[email protected]

สร้างไฟล์ชื่อ index.ts ในโฟลเดอร์นี้ เพิ่มสแนิปเพ็ต TypeScript ที่รันได้ด้านล่างลงในไฟล์เดียวกัน ตามลำดับที่แสดง อย่าสร้างไฟล์แยกสำหรับแต่ละสแนิปเพ็ต คัดลอกเฉพาะสแนิปเพ็ต TypeScript ที่รันได้: บล็อก SQL และเอาต์พุตตัวอย่างเป็นคำอธิบาย ไม่ควรวางลงใน index.ts

การตั้งค่า package.json ที่เป็น type=module ช่วยให้ใช้ await ระดับบนสุดตามตัวอย่างนี้ได้ เอกสารการตั้งค่าแพ็กเกจ Node.js อยู่ใน คู่มือแพ็กเกจ Node.js อย่างเป็นทางการ

แพ็กเกจการเชื่อมต่อของ Oracle ติดตั้ง vector store, @langchain/core จัดเตรียม Document, @langchain/openai จัดเตรียมโมเดล embedding ตัวอย่าง และ oracledb จัดการการเชื่อมต่อฐานข้อมูล เวอร์ชันข้างต้นตรงกับแอปพลิเคชันคู่กัน; tsx รันตัวอย่าง TypeScript ได้โดยตรงโดยไม่ต้องมีขั้นตอนบิลด์แยก

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

ORACLE_USER=your_schema
ORACLE_PASSWORD=your_password
ORACLE_CONNECT_STRING=localhost:1521/FREEPDB1
OPENAI_API_KEY=your_api_key

บันทึกค่าเหล่านี้ไว้ในไฟล์ .env ภายในเครื่อง และเพิ่ม .env ใน .gitignore บทความนี้ใช้ Oracle AI Database Free แบบโลคอลเป็นการตั้งค่าหลักเพื่อให้ทำซ้ำขั้นตอนได้ ฐานข้อมูล Autonomous AI เป็นทางเลือกในการดีพลอยที่ถูกต้อง แต่ต้องใช้ service descriptor และการตั้งค่า wallet หรือ TLS ของสภาพแวดล้อมนั้น

import "dotenv/config";
import oracledb from "oracledb";
import { Document } from "@langchain/core/documents";
import { OpenAIEmbeddings } from "@langchain/openai";
import { OracleVS, DistanceStrategy, VectorElementFormat }
  from "@oracle/langchain-oracledb";

const pool = await oracledb.createPool({
  user: process.env.ORACLE_USER,
  password: process.env.ORACLE_PASSWORD,
  connectString: process.env.ORACLE_CONNECT_STRING,
  poolMin: 1,
  poolMax: 4,
});

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

วิธีสร้างการค้นหาเอกสารด้วย LangChain.js

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

กำหนดเอกสารความรู้

try {
  const documents = [
    ["database-guide", "database", "Oracle AI Database stores vector embeddings alongside application data."],
    ["connection-pooling", "operations", "A connection pool reuses Oracle database sessions across requests."],
    ["vector-indexes", "performance", "HNSW vector indexes can improve nearest-neighbor search as a table grows."],
    ["metadata-filtering", "retrieval", "Metadata filters restrict retrieval to matching categories or sources."],
    ["similarity-search", "retrieval", "Similarity search returns chunks closest to the query embedding."],
    ["mmr-retrieval", "retrieval", "MMR reduces repeated content while keeping results relevant."],
    ["retrieval-overlap-1", "retrieval", "Similarity search may return several near-duplicate passages when multiple notes explain the same retrieval strategy."],
    ["retrieval-overlap-2", "retrieval", "Several notes about the same retrieval strategy can produce repetitive top matches; MMR selects a more diverse set while preserving relevance."],
    ["troubleshooting", "troubleshooting", "For empty results, check ingestion, embeddings, and filters."],
    ["embedding-compatibility", "retrieval", "Ingestion and query retrieval must use compatible dimensions."],
  ].map(([source, category, pageContent]) =>
    new Document({ pageContent, metadata: { source, category } }));

แต่ละ Document มี pageContent และ metadata ฟิลด์ source และ category จะติดไปกับเอกสารตลอดการนำเข้าและการดึงข้อมูล เพื่อให้แอปพลิเคชันอธิบายแหล่งที่มาของผลลัพธ์และจำกัดการค้นหาให้เป็นส่วนที่เกี่ยวข้องได้

กำหนดค่า embeddings และสร้าง OracleVS

  const embeddings = new OpenAIEmbeddings({
    model: "text-embedding-3-small",
  });

  const vectorStore = await OracleVS.fromDocuments(documents, embeddings, {
    client: pool,
    tableName: "LC_JS_RAG_DEMO",
    query: "Oracle AI Database document search",
    distanceStrategy: DistanceStrategy.COSINE,
    format: VectorElementFormat.FLOAT32,
  });

OracleVS.fromDocuments() เป็นการเรียกเชื่อมต่อแกนกลาง มันจะตั้งค่า vector store สร้าง embeddings ให้เอกสารที่ส่งเข้าไป และจัดเก็บเนื้อหา เวกเตอร์ และเมทาดาทาของเอกสารใน Oracle AI Database

พารามิเตอร์ query ให้ตัวอย่างข้อความที่ถูกฝังระหว่างการเริ่มต้นเพื่อกำหนดมิติของเวกเตอร์ที่ต้องใช้สำหรับตารางฐานข้อมูล ไม่ได้นำไปใช้ค้นหาเอกสารที่จัดเก็บไว้ DistanceStrategy.COSINE ระบุมาตรวัดระยะเวกเตอร์ ส่วน VectorElementFormat.FLOAT32 กำหนดรูปแบบองค์ประกอบเวกเตอร์

ก่อนรัน ingestion ซ้ำ ให้ใช้ชื่อตารางสาธิตใหม่หรือเคลียร์ข้อมูลที่มีอยู่เพื่อหลีกเลี่ยงการแทรกเอกสารซ้ำ

OracleVS รองรับการติดตั้งโมเดล embedding ที่เข้ากันกับ LangChain จึงสามารถสลับผู้ให้บริการ embeddings ได้โดยไม่ต้องเปลี่ยนเวิร์กโฟลว์ของ vector store โดยรวม อย่างไรก็ตาม embeddings สำหรับ ingestion และ retrieval ต้องเข้ากันได้กับคอลัมน์เวกเตอร์ของ Oracle

OracleVS กำหนดมิติของเวกเตอร์ระหว่างการเริ่มต้นโดยใช้โมเดล embedding ที่ตั้งค่าไว้ หากต้องการตรวจสอบมิติและรูปแบบการจัดเก็บของเวกเตอร์ที่เก็บไว้แล้วใน Oracle AI Database ให้รันคิวรี SQL ต่อไปนี้:

SELECT
    VECTOR_DIMENSION_COUNT(embedding) AS vector_dimensions,
    VECTOR_DIMENSION_FORMAT(embedding) AS vector_format
FROM LC_JS_RAG_DEMO
FETCH FIRST 1 ROW ONLY;

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

สำหรับซิกเนเจอร์เมธอดของ vector store และตัวเลือกการดึงข้อมูล ดู เอกสารอ้างอิง LangChain.js VectorStore อย่างเป็นทางการ

ดึงเอกสารด้วยการค้นหาความคล้ายคลึง

ตัวอย่างเช่น คำสั่งต่อไปนี้ขอให้ vector store OracleVS ส่งเอกสารที่ใกล้ที่สุด 3 รายการ และพิมพ์เมทาดาทา source พร้อมข้อความของแต่ละชิ้น:

  const retrievalQuestion =
    "How can vector retrieval reduce repetitive results?";
  const results = await vectorStore.similaritySearch(
    retrievalQuestion,
    3
  );
  console.log(results.map((doc) => ({
    source: doc.metadata.source,
    text: doc.pageContent,
  })));

โค้ดจะ map แต่ละ Document ของ LangChain ไปเป็นอ็อบเจ็กต์ธรรมดาที่มี source และ pageContent สำหรับแสดงผล แสดงเอาต์พุตตัวอย่างด้านล่าง; ลำดับที่แน่นอนอาจต่างกันตามโมเดล embedding และคิวรี:

[
  { source: "retrieval-overlap-2", text: "Several notes about the same retrieval strategy can produce repetitive top matches; MMR selects a more diverse set while preserving relevance." },
  { source: "retrieval-overlap-1", text: "Similarity search may return several near-duplicate passages when multiple notes explain the same retrieval strategy." },
  { source: "mmr-retrieval", text: "MMR reduces repeated content while keeping results relevant." }
]

อาร์กิวเมนต์ตัวแรกคือคำถามผู้ใช้ และตัวที่สองคือ k ซึ่งเป็นจำนวนเอกสารสูงสุดที่จะดึง LangChain.js ใช้โมเดล embedding ที่ตั้งค่าไว้เพื่อแปลงคำถามเป็นเวกเตอร์ และ Oracle AI Database ทำ similarity search เพื่อหาเอกสารที่ใกล้ที่สุด

หากมีเอกสารที่เข้าเงื่อนไขน้อยกว่า k หลังใช้เงื่อนไขค้นหาและตัวกรองเมทาดาทา เมธอดจะส่งคืนเฉพาะผลลัพธ์ที่มี เอกสาร Document ที่ดึงมา จะมีข้อความและเมทาดาทาที่สามารถแสดงพร้อมการอ้างอิงที่มาหรือส่งต่อไปยังขั้นตอนสร้างคำตอบภายหลังได้

ตรวจสอบคะแนนการดึงข้อมูล

ตัวอย่างเช่น ใช้ similaritySearchWithScore เมื่อต้องการตรวจสอบค่าระยะที่แนบมากับเอกสารแต่ละรายการที่ดึงได้:

  const scored = await vectorStore.similaritySearchWithScore(
    "Where are document embeddings stored?",
    3
  );

  for (const [doc, score] of scored) {
    console.log({
      text: doc.pageContent,
      source: doc.metadata.source,
      score,
    });
  }

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

จำกัดผลลัพธ์ด้วยตัวกรองเมทาดาทา

  const databaseOnly = await vectorStore.similaritySearch(
    "Where are vector embeddings stored?",
    3,
    { category: { $eq: "database" } }
  );

  console.log(databaseOnly.map((doc) => doc.metadata.source));

เอาต์พุตตัวอย่าง:

["database-guide"]

อาร์กิวเมนต์ตัวที่สามจำกัดการค้นหาให้เป็นรายการที่มี category = database ในคอร์ปัสนี้ ผลลัพธ์ที่คาดได้คือ ["database-guide"] ตัวกรองเปลี่ยนชุดเอกสารที่มีสิทธิ์; การจัดอันดับยังคงใช้ความคล้ายคลึงของเวกเตอร์ในชุดที่มีสิทธิ์

ใช้ MMR เพื่อลดผลลัพธ์ซ้ำซ้อน

  const diverse = await vectorStore.maxMarginalRelevanceSearch(
    retrievalQuestion,
    {
      k: 3,
      fetchK: 6,
      lambda: 0.5,
    }
  );
  console.log(diverse.map((doc) => doc.metadata.source));

เอาต์พุตตัวแทนจากคอร์ปัสที่ซ้อนทับกัน (ลำดับอาจต่างกันตามโมเดล embedding และการรัน):

["retrieval-overlap-2", "mmr-retrieval", "metadata-filtering"]

MMR พิจารณาชุดผู้สมัครก่อน (fetchK) แล้วเลือกเอกสาร k รายการโดยถ่วงดุลความเกี่ยวข้องของคิวรีกับความหลากหลาย ค่า lambda ต่ำจะเน้นความหลากหลายมากขึ้น; ค่าสูงจะเน้นความเกี่ยวข้องมากขึ้น ด้วยคอร์ปัสที่ซ้อนทับกันข้างต้น แหล่งที่มาที่เลือกอาจต่างจาก similarity search ปกติ ทำให้เห็นภาพการแลกเปลี่ยนของการดึงข้อมูล

ส่งต่อบริบทที่ดึงมาไปยังแอปพลิเคชัน AI

  const question = "How does LangChain.js retrieve Oracle documents?";
  const contextDocs = await vectorStore.similaritySearch(question, 3);

  const context = contextDocs
    .map((doc, i) => `[${i + 1}] ${doc.pageContent}`)
    .join("\n\n");

  console.log({ question, context });

นี่คือจุดส่งต่อระหว่างการดึงข้อมูลของ LangChain.js และการเรียกโมเดลภาษาขนาดใหญ่ (LLM): แอปพลิเคชันมีคำถามและหลักฐานที่ตรวจสอบได้ พร้อมสำหรับพรอมป์ตที่ให้โมเดลตอบจากบริบทนั้น

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

วิธีตรวจสอบความถูกต้องของการผสาน

การตรวจสอบที่มีประโยชน์คือเช็กการนำเข้าและกลยุทธ์การดึงข้อมูลแต่ละแบบแยกกัน ก่อนอื่นยืนยันว่าได้สร้าง vector store โดยไม่เกิดข้อผิดพลาดในฐานข้อมูล จากนั้นตรวจสอบเมทาดาทาแหล่งที่มาที่ได้จาก similarity search ผลลัพธ์แบบกรอง และผลลัพธ์ของ MMR

  const check = await vectorStore.similaritySearch(
    "How does OracleVS connect to LangChain.js?",
    3
  );

  if (check.length === 0) {
    throw new Error("No documents retrieved; inspect ingestion and filters.");
  }

  console.log({
    similarity: check.map((doc) => doc.metadata.source),
    filtered: databaseOnly.map((doc) => doc.metadata.source),
    mmr: diverse.map((doc) => doc.metadata.source),
  });

ปิดพูลการเชื่อมต่อหลังการตรวจสอบ

} finally {
  await pool.close(10);
}

ขั้นตอนทำความสะอาดจะทำงานหลังจากเสร็จสิ้นการนำเข้า การดึงข้อมูล และการตรวจสอบแล้วเท่านั้น เวลา drain เปิดโอกาสให้การเชื่อมต่อที่กำลังใช้งานเสร็จสิ้น ในเซิร์ฟเวอร์ที่รันยาว ควรรักษาพูลให้เปิดจนถึงการปิดระบบแบบสุภาพ ดูรายละเอียดวงจรชีวิตได้ที่ เอกสาร pool.close() ของ node-oracledb

ณ จุดนี้ ไฟล์ index.ts ฉบับสมบูรณ์สามารถรันได้ด้วย:

npx tsx index.ts

เอาต์พุตการตรวจสอบตัวอย่างคือ:

{
  similarity: ["retrieval-overlap-1", "retrieval-overlap-2", "mmr-retrieval"],
  filtered: ["database-guide"],
  mmr: ["retrieval-overlap-2", "mmr-retrieval", "metadata-filtering"]
}

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

เคล็ดลับและการแก้ปัญหา

เชื่อมต่อฐานข้อมูลไม่สำเร็จ

ตรวจสอบสตริงการเชื่อมต่อ ข้อมูลรับรอง บริการที่เข้าถึงได้ และสิทธิ์ของสคีมา หากใช้ Autonomous AI Database ให้ยืนยันการตั้งค่า wallet หรือ TLS ที่จำเป็น ทดสอบการเชื่อมต่อฐานข้อมูลแยกต่างหากก่อนดีบักการดึงข้อมูล

เกิดความไม่ตรงกันของมิติ embedding

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

การค้นหาไม่ส่งคืนเอกสาร

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

ผลลัพธ์เกี่ยวข้องแต่ซ้ำซ้อน

เปรียบเทียบ similarity search กับ MMR โดยใช้คอร์ปัสที่มีชิ้นส่วนทับซ้อนกัน ปรับค่า k, fetchK และ lambda พร้อมตรวจสอบว่าความหลากหลายแลกกับการพลาดข้อความสำคัญหรือไม่

ควรสร้างดัชนีเวกเตอร์หรือไม่?

สำหรับชุดข้อมูลตัวอย่างขนาดเล็ก เริ่มจากการตรวจความถูกต้องโดยไม่ต้องจูนดัชนี เมื่อข้อมูลเติบโต ให้ประเมิน ดัชนีเวกเตอร์ของ Oracle เช่น Hierarchical Navigable Small World (HNSW) หรือ Inverted File (IVF) ตามความต้องการด้านประสิทธิภาพและความแม่นยำ การสร้างดัชนีเป็นการปรับแต่ง ไม่ใช่ข้อกำหนดเบื้องต้นสำหรับทำความเข้าใจการผสานขั้นพื้นฐาน

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับดัชนีเวกเตอร์ของ Oracle โปรดดู เอกสารดัชนีเวกเตอร์ของ Oracle

สำรวจโค้ดอ้างอิง TypeScript ที่สมบูรณ์

เพื่อดูว่าคอนเซ็ปต์เหล่านี้ทำงานร่วมกันในแอปพลิเคชันจริงอย่างไร ลองสำรวจ แอปอ้างอิง LangChain.js และ Oracle AI Database

แอปพลิเคชันนี้สร้างด้วย TypeScript รวบรวมการนำเอกสารเข้า การจัดเก็บเวกเตอร์ การค้นหาความคล้ายคลึง การกรองด้วยเมทาดาทา และ MMR โดยใช้ LangChain.js และ Oracle AI Database นอกจากนี้ยังมีอินเทอร์เฟซแบบโต้ตอบสำหรับทดลองการตั้งค่าการดึงข้อมูล ตรวจสอบเอกสารที่ดึงมา และทำความเข้าใจว่ากลยุทธ์การค้นหาที่ต่างกันส่งผลต่อบริบทที่ส่งกลับไปยังแอปพลิเคชันอย่างไร

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

บทสรุปและขั้นตอนถัดไป

ได้เชื่อมต่อ LangChain.js กับ Oracle AI Database ผ่าน OracleVS แทนความรู้เป็นอ็อบเจ็กต์ Document สร้าง embeddings ของเวกเตอร์แบบถาวร และเปรียบเทียบ similarity search การกรองเมทาดาทา และ MMR แล้ว สำหรับขั้นตอนถัดไป โปรดอ่าน เอกสาร LangChain.js และ คู่มือการเชื่อมต่อ Oracle LangChain JavaScript อย่างเป็นทางการ

หากทำงานในภาษาอื่น บทเรียน Oracle AI Vector Search ครอบคลุมขั้นตอนการจัดเก็บและคิวรีเดียวกันใน Python และ บทเรียน LangChain4j สร้างเอเจนต์ภาษา Java กับ Oracle AI Database

คอร์ส Retrieval Augmented Generation (RAG) with LangChain เป็นคอร์สต่อยอดที่เน้นการดึงข้อมูล ตัวอย่างเป็นภาษา Python แต่แนวคิดเวิร์กโฟลว์ใช้ได้กับการติดตั้ง TypeScript นี้

คำถามที่พบบ่อย

จะเกิดอะไรขึ้นหากเปลี่ยนโมเดล embedding หลังจากจัดเก็บเอกสารแล้ว?

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

จำเป็นต้องมีโมเดลแชทเพื่อใช้ OracleVS หรือไม่?

ไม่จำเป็น เวิร์กโฟลว์ของ vector store ต้องการโมเดล embedding สำหรับการนำเข้าและคิวรี โมเดลแชทเป็นตัวเลือกและโดยทั่วไปจะเพิ่มเมื่อจำเป็นต้องแปลงข้อความที่ดึงมาให้เป็นคำตอบภาษาธรรมชาติ

สามารถใช้ผู้ให้บริการ embedding ที่ไม่ใช่ OpenAI ได้หรือไม่?

ได้ OracleVS รองรับการติดตั้ง embedding ของ LangChain ที่เข้ากันได้ เลือกผู้ให้บริการที่ตรงตามความต้องการ และใช้การตั้งค่า embedding ที่เข้ากันได้เดียวกันกับเอกสารและคิวรี

ทำไมต้องใช้การกรองเมทาดาทาร่วมกับความคล้ายคลึงของเวกเตอร์?

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

ควรเลือก MMR แทนการค้นหาความคล้ายคลึงแบบปกติเมื่อใด?

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

Daniela Pavlenco

ผู้เขียน

Daniela Pavlenco

ทำงานเป็นผู้เชี่ยวชาญด้านการสนับสนุนนักพัฒนาที่ Oracle มุ่งช่วยให้นักพัฒนาสำรวจเทคโนโลยีด้านปัญญาประดิษฐ์และสร้างแอปพลิเคชันที่ใช้งานได้จริงด้วยเครื่องมือและเฟรมเวิร์กสมัยใหม่ งานที่ทำครอบคลุมการสร้างคอนเทนต์เชิงเทคนิค ตัวอย่างแบบลงมือปฏิบัติ และทรัพยากรสำหรับนักพัฒนา เพื่อทำให้แนวคิดที่ซับซ้อนเข้าใจง่ายและนำไปใช้ได้จริงในโครงการของโลกความเป็นจริง

หัวข้อ