在上一篇文中，我們有從這篇論文中有提到兩種 RAG Post-Retrieval 的主要方向分別為 :

• Reranking
• Context Compressing

Retrieval-Augmented Generation for Large Language Models: A Survey

然後接下來我們就要說說 Context Compressing 的手法。

🚀 Context Compressing 的手法

不是把 retrieve 出來的 document 原封不動返回，而是根據該查詢的脈絡對它們進行壓縮，只回傳與查詢相關的資訊

上面這是整個 Context Compressing 的思想核心，然後相關手法事實上很多，我們可以參考這份論文 :

Contextual Compression in Retrieval-Augmented Generation for Large Language Models: A Survey

主要可以分為以下幾大類與核心概念 :

• Semantic Compression : 在我們將 Contexts ( 就我們第一次 retrive 的結果 ) 丟給 LLM，會先根據語意來進行壓縮。
• Pre-Trained Language Models : 訓練專門的模型架構來「學會壓縮」。
• Retrievers : 在 retrieve 階段就過濾掉無關資訊。

圖片來源: Contextual Compression in Retrieval-Augmented Generation for Large Language Models: A Survey

然後這裡我請 GPT 幫我整理成表格，方便之後查詢，有簡單的檢查一下，應該是沒和原文差太多。

Semantic Compression ( AI 產 )

Pre-Trained Language Models ( AI 產 )

Retrievers ( AI 產 )

然後這篇文章主要會以 Retrievers 為主，主要的原因在於 Semantic Compression 與 Pre-Trained Language Models 我有點兒想不到怎麼做．學不完啊……

🚀 LangChain 的 Contextual Compression 功能

它有提供三種功能，但我們就談前二個，因為第三個就直接將功能合在一起。

• LLMChainExtractor
• EmbeddingsFilter
• DocumentCompressorPipeline ( 不說 )

🤔 LLMChainExtractor

首先 LLMChainExtractor 功能白話文就是 :

叫 LLM 幫我們來將第一次 retrive 後的結果，再次找出更相關的 doc。

範例程式碼如下，其中 4 就是我們這個地方的重點。

  const embeddings = new OpenAIEmbeddings({ 
    model: "text-embedding-3-small" 
  });
  const vectorStore = await MemoryVectorStore.fromDocuments(docs, embeddings);
  const baseRetriever = vectorStore.asRetriever({ k: 10 }); // 先檢索較多文件

  // 3. 建立 LLM（用於抽取）
  const llm = new ChatOpenAI({
    model: "gpt-4o-mini",
    temperature: 0, // 設為 0 以獲得更確定性的抽取結果
  });

  // 4. 建立 LLMChainExtractor
  const compressor = LLMChainExtractor.fromLLM(llm);

  // 5. 包裝成 ContextualCompressionRetriever
  const retriever = new ContextualCompressionRetriever({
    baseCompressor: compressor,
    baseRetriever: baseRetriever,
  });

  // 6. 執行查詢
  console.log(`📝 查詢: "${query}"\n`);
  
  const compressedDocs = await retriever.invoke(query);

然後這裡有幾個重點要記得 :

你第一次 retrieve 有幾個 document，就會呼叫幾次 LLM，你可以用 process.env.LANGCHAIN_VERBOSE = "true" 打開 debug 模式來看看

然後我們也順到看看他實際上的 prompt 長什麼樣子，如果之後你自已要實作 LLM compression prompt 也可以參考看看 LangChain 這的 prompt。

Query: RAG 如何降低幻覺問題？
Document: "[00:10] 嗯...今天我們要講的是 RAG，就是...那個...檢索增強生成。
RAG 的核心概念是結合外部知識庫和大型語言模型。
它可以有效降低 LLM 的幻覺問題，提供更準確的回答。
不過 RAG 也有一些挑戰，比如檢索到的內容可能包含很多無關資訊"


LangChain 產的 prompt ======================================================

[llm/start] [1:chain:LLMChain > 2:llm:ChatOpenAI] Entering LLM run with input: {
  "messages": [
    [
      {
        "lc": 1,
        "type": "constructor",
        "id": [
          "langchain_core",
          "messages",
          "HumanMessage"
        ],
        "kwargs": {
          "content": "Given the following question and context, extract any part of the context *AS IS* that is relevant to answer the question. If none of the context is relevant return NO_OUTPUT.\n\nRemember, *DO NOT* edit the extracted parts of the context.\n\n> Question: RAG 如何降低幻覺問題？\n> Context:\n>>>\n\n[00:10] 嗯...今天我們要講的是 RAG，就是...那個...檢索增強生成。\nRAG 的核心概念是結合外部知識庫和大型語言模型。\n它可以有效降低 LLM 的幻覺問題，提供更準確的回答。\n不過 RAG 也有一些挑戰，比如檢索到的內容可能包含很多無關資訊。\n\n>>>\nExtracted relevant parts:",
          "additional_kwargs": {},
          "response_metadata": {}
        }
      }
    ]
  ]
}

🤔 EmbeddingsFilter

事實上它就只是 retrive 後根據它的 score 進行 filter。

https://js.langchain.com/docs/how_to/contextual_compression/

LangChain 中有個叫 ContextualCompressionRetriever 的東西，可以將我們第一次 retrive 後的東西，再進行 compressing，其中 EmbeddingsFilter 就是的地方。

  const docs: Document[] = […… 你的原始資料];
  const query = "如何在 RAG 降低成本與去除無關內容？";

  // 2) 建 vector store + 基礎檢索器
  const embeddings = new OpenAIEmbeddings({ model: "text-embedding-3-small" });
  const store = await MemoryVectorStore.fromDocuments(docs, embeddings);
  const baseRetriever = store.asRetriever(12); // 先取寬一些

  // 3) EmbeddingsFilter：設定門檻與最多保留數
  const compressor = new EmbeddingsFilter({
    embeddings,
    similarityThreshold: 0.5, // 0~1，語料越同質可拉高
    k: 4,
  });

  // 4) 包裝成 ContextualCompressionRetriever
  const retriever = new ContextualCompressionRetriever({
    baseRetriever,
    baseCompressor: compressor,
  });

  // 5) 查詢 + 輸出
  const reduced = await retriever.invoke(query);

然後我當初在看這東西時覺得很出怪。

因為它不就是一個根據第一次 retrive 後的分數，來再根據 similarityThreshold 進行一次塞選嗎 ?

我們是不是也可以用這種寫法來處理呢 ?

// ✅ 技術上完全可行
const resultsWithScore = await store.similaritySearchWithScore(query, 12);

const filtered = resultsWithScore
  .filter(([doc, score]) => score >= 0.5)  // 手動過濾
  .slice(0, 4)
  .map(([doc, score]) => doc);

console.log(filtered);

原理上是對的，而且我以為他是有在 embedding 過，但發現沒有。

那為什麼 LangChain 還要提到這個呢 ? 因為以下幾個原因 :

• 不同的 VectorStore 分數計算方式可能不一致。
• 某些 VectorStore 不支援 withScore。

所以事實上還是會建議使用。不過有點奇怪 1.0.0 的文件沒看到這個章節，只有在這裡有看到，不確定他們是不是偷偷讓每個 Store 的分數都統一了……

https://v02.api.js.langchain.com/classes/langchain.retrievers_contextual_compression.ContextualCompressionRetriever.html

🚀 實作 - 整合到字幕檔實作 AI 課程問答功能

接下來我們將上面的東西，整合到我們的功能中。

這個地方我們就只實作 EmbeddingsFilter，主要的原因在於 LLMChainExtractor 真的有點太耗錢了，所以除非結果真的非常不理想，不然應該還是先考慮只用 EmbeddingsFilter。

然後接下來我們來看程式碼修改後的地方。

首先最外層還是一樣沒變，如下，然後改變的是在 Stage 2 的 Vector Search 中，會加入相關的功能。

const query = async (message: string) => {
    // ===== Stage 1: Query Expansion ( Pre-Retrieval ) =====
    const queryVariants = await this.generateQueryVariants(
      originalQuery,
      this.config.numQueryVariants
    );
    const hypotheticalAnswer = await this.generateHypotheticalAnswer(
      originalQuery
    );
    const searchQueries = [originalQuery, ...queryVariants, hypotheticalAnswer];

    // ===== Stage 2: Vector Search =====
    console.log(`\n--- Stage 2: Vector Search ---`);
    const candidates = await this.vectorSearch(
      searchQueries,
      k * this.config.retrievalMultiplier
    );

    // ===== Stage 3: Temporal Cluster ( Post-Retrieval ) =====
    const clustered = this.temporalReranker.rerank(candidates, k * 2);

    // ===== Stage 4: Voyage Reranking ( Post-Retrieval ) =====
    const contexts = await this.voyageReranker.rerank(originalQuery, clustered, k);

     // ===== Stage 5: 將 Context 代到 Prompt 中生成答案 =====
    const result = await model.invoke([
    {
      role: "system",
      content: `
        # Context: ${contexts
          .map((c, i) => {
            return `[${i + 1}] 時間: ${formatTime(
              c.metadata.start_ms
            )}-${formatTime(c.metadata.end_ms)} | 相關性: ${
              c.rerank_score?.toFixed(3) || "N/A"
            }
        內容: ${c.pageContent}`;
          })
          .join("\n\n")} 
        
          # Instructions:
          - 你只能根據 Context 回答相關的問題
          - 說明答案的來源時間範圍（格式: "MM:SS~MM:SS"）
          - 限制在 500 個字以內
          - 如果 Context 中沒有相關信息，誠實告知
        `,
    },
    { role: "user", content: message },
    ]);
};

下面程式碼就是 vector search 裡面，然後我們有加上了 EmbeddingsFilter ，然後透過 ContextualCompressionRetriever 將會根據 similarityThreshold 來進行 compress。

但是這裡我實驗後發現，如果我將 similarityThreshold 設為 0.7 後，就幾乎都拿不到結果，但他的確幫我們移除掉了很多不相關的資料，因此在後面的處理就更省空間與速度了，的確幫助很大。

      const baseRetriever = await this.vectorStore.asRetriever(
        Math.ceil(totalK / queries.length) + 5
      );

      // ===== Step New: 加上 Contextual Compression Retriever =====
      const compressor = new EmbeddingsFilter({
        embeddings: this.vectorStore.embeddings,
        similarityThreshold: 0.5, // 0~1，語料越同質可拉高
        k: 4,
      });
      const retriever = new ContextualCompressionRetriever({
        baseRetriever,
        baseCompressor: compressor,
      });

事實上沒啥技術，但也是種思路。

🚀 小總結

今天的文章我們大概看了一下整個 Context Compressing 的方法體系，看完後真的發覺得水好深，所以我們最後只抓了 Retrievers 那個地方的手法來實作，事實上我自已覺得效果算不錯，已經清掉不少不需要的 context 了，但就只是覺得好像沒啥技術成分在。

這篇我自已覺得有點水誒 Semantic Compression 的手法都沒實作到，唉 ~

🚀 參考資料

• langChain-contextual_compression
• Contextual Compression in Retrieval-Augmented Generation for Large Language Models: A Survey