基礎RAG實現，最佳入門選擇（八）

RAG重排序

RAG重排序技術以提高RAG系統中的檢索質量。重新排序充當初始檢索后的第二個過濾步驟，以確保最相關的內容用于響應生成。

重排序的關鍵概念

1.初始檢索：使用基本相似度搜索的第一遍（準確度較低但速度更快）
2.文檔評分：評估每個檢索到的文檔與查詢的相關性
3.重新排序：按相關性分數對文檔進行排序
4.選擇：僅使用最相關的文檔生成響應

具體代碼實現

PDF文本處理與分塊

PDF文件中提取全部文本

def extract_text_from_pdf(pdf_path: str) -> str:"""從PDF文件中提取全部文本。"""print(f"[PDF提取] 正在提取: {pdf_path}")with open(pdf_path, 'rb') as f:reader = PdfReader(f)text = ""for i, page in enumerate(reader.pages):page_text = page.extract_text()if page_text:text += page_textprint(f"  - 已提取第{i+1}頁")print(f"[PDF提取] 完成，總長度: {len(text)} 字符\n")return text

文本分割為帶重疊的塊

def chunk_text(text: str, n: int = 1000, overlap: int = 200) -> List[str]:"""將文本分割為帶重疊的塊。"""print(f"[分塊] 每塊{n}字符，重疊{overlap}字符")chunks = []for i in range(0, len(text), n - overlap):chunks.append(text[i:i + n])print(f"[分塊] 完成，共{len(chunks)}塊\n")return chunks

向量生成與存儲

阿里embedding模型批量生成文本向量

def create_embeddings(texts, model: str = EMBEDDING_MODEL) -> List[np.ndarray]:"""用阿里embedding模型批量生成文本向量。支持單條或多條文本。"""if isinstance(texts, str):texts = [texts]print(f"[嵌入生成] 正在生成{len(texts)}條文本的向量...")try:response = TextEmbedding.call(model=model,input=texts,api_key=ALI_API_KEY)if response.status_code == 200:embeddings = [np.array(item['embedding']) for item in response.output['embeddings']]print(f"[嵌入生成] 成功，返回{len(embeddings)}條向量\n")return embeddings if len(embeddings) > 1 else embeddings[0]else:print(f"[嵌入生成] 失敗: {response.message}")return [np.zeros(1536)] * len(texts)except Exception as e:print(f"[嵌入生成] 異常: {e}")return [np.zeros(1536)] * len(texts)

簡單的向量存儲與檢索類

class SimpleVectorStore:"""簡單的向量存儲與檢索類。"""def __init__(self):self.vectors = []self.texts = []self.metadata = []def add_item(self, text, embedding, metadata=None):self.vectors.append(np.array(embedding))self.texts.append(text)self.metadata.append(metadata or {})def similarity_search(self, query_embedding, k=5):if not self.vectors:return []query_vector = np.array(query_embedding)similarities = []for i, vector in enumerate(self.vectors):sim = np.dot(query_vector, vector) / (np.linalg.norm(query_vector) * np.linalg.norm(vector))similarities.append((i, sim))similarities.sort(key=lambda x: x[1], reverse=True)results = []for i in range(min(k, len(similarities))):idx, score = similarities[i]results.append({"text": self.texts[idx],"metadata": self.metadata[idx],"similarity": score})return results

文檔處理主流程

處理PDF文檔，提取文本、分塊、生成向量并構建向量庫

def process_document(pdf_path: str, chunk_size: int = 1000, chunk_overlap: int = 200) -> SimpleVectorStore:"""處理PDF文檔，提取文本、分塊、生成向量并構建向量庫。"""print("[主流程] 開始處理文檔...")extracted_text = extract_text_from_pdf(pdf_path)text_chunks = chunk_text(extracted_text, chunk_size, chunk_overlap)print("[主流程] 初始化向量庫...")vector_store = SimpleVectorStore()print("[主流程] 為每個塊生成向量...")chunk_embeddings = create_embeddings(text_chunks)for i, (chunk, embedding) in enumerate(zip(text_chunks, chunk_embeddings)):print(f"[塊{i+1}/{len(text_chunks)}] 已生成向量，長度: {len(chunk)} 字符")vector_store.add_item(chunk, embedding, {"type": "chunk", "index": i})print("[主流程] 文檔處理完畢，向量庫構建完成\n")return vector_store

LLM重排序

LLM對初步檢索結果進行重排序

def rerank_with_llm(query: str, results: List[Dict], top_n: int = 3, model: str = LLM_MODEL) -> List[Dict]:"""使用LLM對初步檢索結果進行重排序。"""print(f"[重排序] 對{len(results)}個文檔進行LLM重排序...")scored_results = []system_prompt = "你是文檔相關性評估專家，請根據用戶問題對下列文檔相關性打分，0-10分，10分最相關。只返回分數，不要輸出其他內容。"for i, result in enumerate(results):if i % 5 == 0:print(f"[重排序] 正在評估第{i+1}/{len(results)}個文檔...")user_prompt = f"""問題: {query}\n\n文檔內容:\n{result['text']}\n\n請對該文檔與問題的相關性打分（0-10分）："""try:response = Generation.call(model=model,messages=[{"role": "system", "content": system_prompt},{"role": "user", "content": user_prompt}],api_key=ALI_API_KEY,result_format='message')score_text = response.output.choices[0].message.content.strip()score_match = re.search(r'\b(10|[0-9])\b', score_text)if score_match:score = float(score_match.group(1))else:print(f"[重排序] 警告: 無法提取分數，使用相似度分數代替: '{score_text}'")score = result["similarity"] * 10except Exception as e:print(f"[重排序] LLM調用異常: {e}，使用相似度分數代替")score = result["similarity"] * 10scored_results.append({"text": result["text"],"metadata": result["metadata"],"similarity": result["similarity"],"relevance_score": score})reranked_results = sorted(scored_results, key=lambda x: x["relevance_score"], reverse=True)print(f"[重排序] 完成，返回Top{top_n}結果\n")return reranked_results[:top_n]

關鍵詞重排序

關鍵詞匹配對初步檢索結果進行簡單重排序

def rerank_with_keywords(query: str, results: List[Dict], top_n: int = 3) -> List[Dict]:"""使用關鍵詞匹配對初步檢索結果進行簡單重排序。"""print(f"[關鍵詞重排序] 對{len(results)}個文檔進行關鍵詞重排序...")keywords = [word.lower() for word in query.split() if len(word) > 3]scored_results = []for result in results:document_text = result["text"].lower()base_score = result["similarity"] * 0.5keyword_score = 0for keyword in keywords:if keyword in document_text:keyword_score += 0.1first_position = document_text.find(keyword)if first_position < len(document_text) / 4:keyword_score += 0.1frequency = document_text.count(keyword)keyword_score += min(0.05 * frequency, 0.2)final_score = base_score + keyword_scorescored_results.append({"text": result["text"],"metadata": result["metadata"],"similarity": result["similarity"],"relevance_score": final_score})reranked_results = sorted(scored_results, key=lambda x: x["relevance_score"], reverse=True)print(f"[關鍵詞重排序] 完成，返回Top{top_n}結果\n")return reranked_results[:top_n]

回答生成

def generate_response(query: str, context: str, model: str = LLM_MODEL) -> str:"""用大模型基于上下文生成回答。"""print("[生成] 正在調用大模型生成回答...")system_prompt = "你是一個AI助手，只能基于給定上下文回答問題。如果上下文無法直接回答，請回復：'信息不足，無法回答。'"user_prompt = f"""
上下文：\n{context}\n\n問題：{query}\n\n請只基于上述上下文簡明準確作答。"""try:response = Generation.call(model=model,messages=[{"role": "system", "content": system_prompt},{"role": "user", "content": user_prompt}],api_key=ALI_API_KEY,result_format='message')answer = response.output.choices[0].message.content.strip()print(f"[生成] 回答生成成功: {answer}\n")return answerexcept Exception as e:print(f"[生成] 回答生成異常: {e}")return ""

RAG主流程

def rag_with_reranking(query: str, vector_store: SimpleVectorStore, reranking_method: str = "llm", top_n: int = 3, model: str = LLM_MODEL) -> Dict:"""完整RAG流程，包含初步檢索、重排序和回答生成。"""print(f"[RAG] 開始RAG流程，檢索+重排序方法: {reranking_method}")query_embedding = create_embeddings(query)initial_results = vector_store.similarity_search(query_embedding, k=10)if reranking_method == "llm":reranked_results = rerank_with_llm(query, initial_results, top_n=top_n)elif reranking_method == "keywords":reranked_results = rerank_with_keywords(query, initial_results, top_n=top_n)else:reranked_results = initial_results[:top_n]context = "\n\n===\n\n".join([result["text"] for result in reranked_results])response = generate_response(query, context, model)print(f"[RAG] 流程完成\n")return {"query": query,"reranking_method": reranking_method,"initial_results": initial_results[:top_n],"reranked_results": reranked_results,"context": context,"response": response}

附錄

效果展示

===== RAG重排序增強示例 =====[主流程] 開始處理文檔...
[PDF提取] 正在提取: data/2888年Java程序員找工作最新場景題.pdf- 已提取第1頁- 已提取第2頁- 已提取第3頁- 已提取第4頁- 已提取第5頁- 已提取第6頁- 已提取第7頁- 已提取第8頁- 已提取第9頁- 已提取第10頁
[PDF提取] 完成，總長度: 6984 字符[分塊] 每塊1000字符，重疊200字符
[分塊] 完成，共9塊[主流程] 初始化向量庫...
[主流程] 為每個塊生成向量...
[嵌入生成] 正在生成9條文本的向量...
[嵌入生成] 成功，返回9條向量[塊1/9] 已生成向量，長度: 1000 字符
[塊2/9] 已生成向量，長度: 1000 字符
[塊3/9] 已生成向量，長度: 1000 字符
[塊4/9] 已生成向量，長度: 1000 字符
[塊5/9] 已生成向量，長度: 1000 字符
[塊6/9] 已生成向量，長度: 1000 字符
[塊7/9] 已生成向量，長度: 1000 字符
[塊8/9] 已生成向量，長度: 1000 字符
[塊9/9] 已生成向量，長度: 584 字符
[主流程] 文檔處理完畢，向量庫構建完成[主流程] 向量庫已構建，開始不同重排序方法對比...=== 標準檢索（無重排序） ===
[RAG] 開始RAG流程，檢索+重排序方法: none
[嵌入生成] 正在生成1條文本的向量...
[嵌入生成] 成功，返回1條向量[生成] 正在調用大模型生成回答...
[生成] 回答生成成功: 根據上下文，Java程序員面試中常見的技術問題包括但不限于：- 分布式架構相關知識：如CAP原則、微服務架構、彈性設計以及Spring Cloud、CloudNative等相關技術框架的理解。
- 網絡編程技能：理解TCP/IP協議的三次握手與四次揮手過程，掌握Socket編程基礎，了解select、poll、epoll等I/O多路復用技術。
- 項目經驗分享：面試官會詢問候選人關于他們參與過的項目細節，特別是那些最自豪或最具挑戰性的項目經歷，以及如何解決遇到的技術難題。此外，還可能要求講述曾經犯下的最大技術失誤及從中學習到的經驗教訓。這些問題旨在考察求職者的實際工作經驗、解決問題的能力和技術深度。[RAG] 流程完成Query: Java程序員面試中常見的技術問題有哪些？Response:
根據上下文，Java程序員面試中常見的技術問題包括但不限于：- 分布式架構相關知識：如CAP原則、微服務架構、彈性設計以及Spring Cloud、CloudNative等相關技術框架的理解。
- 網絡編程技能：理解TCP/IP協議的三次握手與四次揮手過程，掌握Socket編程基礎，了解select、poll、epoll等I/O多路復用技術。
- 項目經驗分享：面試官會詢問候選人關于他們參與過的項目細節，特別是那些最自豪或最具挑戰性的項目經歷，以及如何解決遇到的技術難題。此外，還可能要求講述曾經犯下的最大技術失誤及從中學習到的經驗教訓。這些問題旨在考察求職者的實際工作經驗、解決問題的能力和技術深度。=== LLM重排序 ===
[RAG] 開始RAG流程，檢索+重排序方法: llm
[嵌入生成] 正在生成1條文本的向量...
[嵌入生成] 成功，返回1條向量[重排序] 對9個文檔進行LLM重排序...
[重排序] 正在評估第1/9個文檔...
[重排序] 正在評估第6/9個文檔...
[重排序] 完成，返回Top3結果[生成] 正在調用大模型生成回答...
[生成] 回答生成成功: 根據上下文，Java程序員面試中常見的技術問題涉及以下幾個方面：- 并發編程、NIO、JVM等進階知識。
- Spring、Netty等流行框架的基本原理。
- 對于分布式架構的理解，包括CAP原則、微服務架構（如Spring Cloud）、彈性設計及云原生(Cloud Native)技術。
- 網絡編程相關知識，比如TCP/IP協議的三次握手和四次揮手過程，Socket編程基礎，以及I/O多路復用技術(select, poll, epoll)。這些問題旨在評估應聘者對于所列技術的實際掌握程度和技術深度。[RAG] 流程完成Query: Java程序員面試中常見的技術問題有哪些？Response:
根據上下文，Java程序員面試中常見的技術問題涉及以下幾個方面：- 并發編程、NIO、JVM等進階知識。
- Spring、Netty等流行框架的基本原理。
- 對于分布式架構的理解，包括CAP原則、微服務架構（如Spring Cloud）、彈性設計及云原生(Cloud Native)技術。
- 網絡編程相關知識，比如TCP/IP協議的三次握手和四次揮手過程，Socket編程基礎，以及I/O多路復用技術(select, poll, epoll)。這些問題旨在評估應聘者對于所列技術的實際掌握程度和技術深度。=== 關鍵詞重排序 ===
[RAG] 開始RAG流程，檢索+重排序方法: keywords
[嵌入生成] 正在生成1條文本的向量...
[嵌入生成] 成功，返回1條向量[關鍵詞重排序] 對9個文檔進行關鍵詞重排序...
[關鍵詞重排序] 完成，返回Top3結果[生成] 正在調用大模型生成回答...
[生成] 回答生成成功: 根據上下文，Java程序員面試中常見的技術問題包括但不限于：- 分布式架構相關：CAP原則的理解、微服務架構的應用、彈性設計的概念以及Spring Cloud和Cloud Native等技術框架的使用。
- 網絡編程基礎：TCP/IP協議的工作機制（如三次握手、四次揮手），Socket編程的基礎知識，還有I/O多路復用技術（select, poll, epoll）的應用。此外，還強調了對項目經驗和技術深度思考的考察，比如要求候選人分享他們最自豪或最近完成的項目、解決過的復雜難題、經歷過的挑戰性項目以及曾經犯下的最大技術失誤等。這些問題旨在評估候選人的實際操作能力、解決問題的能力及面對錯誤的態度。[RAG] 流程完成Query: Java程序員面試中常見的技術問題有哪些？Response:
根據上下文，Java程序員面試中常見的技術問題包括但不限于：- 分布式架構相關：CAP原則的理解、微服務架構的應用、彈性設計的概念以及Spring Cloud和Cloud Native等技術框架的使用。
- 網絡編程基礎：TCP/IP協議的工作機制（如三次握手、四次揮手），Socket編程的基礎知識，還有I/O多路復用技術（select, poll, epoll）的應用。此外，還強調了對項目經驗和技術深度思考的考察，比如要求候選人分享他們最自豪或最近完成的項目、解決過的復雜難題、經歷過的挑戰性項目以及曾經犯下的最大技術失誤等。這些問題旨在評估候選人的實際操作能力、解決問題的能力及面對錯誤的態度。進程已結束，退出代碼為 0

完整代碼示例

# -*- coding: utf-8 -*-
"""
RAG重排序增強腳本（基于阿里云通義千問Qwen）
========================================
本腳本實現了RAG檢索增強中的重排序（rerank）流程，所有大模型調用均基于阿里云通義千問Qwen，密鑰從api_keys.py讀取。
每一步均有詳細控制臺輸出，便于觀察效果。
"""
import os
import numpy as np
import json
import re
from typing import List, Dict
from PyPDF2 import PdfReader
from dashscope import Generation, TextEmbedding# ========== 密鑰配置 ==========
# try:
#     from test.api_keys import ALI_API_KEY
# except ImportError:
#     raise RuntimeError("未找到test/api_keys.py或未定義ALI_API_KEY，請配置API密鑰！")
ALI_API_KEY="sk-148deabc0bcf4fdeaa70a78eaa829c7e"
# =============================LLM_MODEL = "qwen-max"  # 通義千問主力模型
EMBEDDING_MODEL = "text-embedding-v2"  # 阿里云嵌入模型# ========== PDF文本處理與分塊 ==========
def extract_text_from_pdf(pdf_path: str) -> str:"""從PDF文件中提取全部文本。"""print(f"[PDF提取] 正在提取: {pdf_path}")with open(pdf_path, 'rb') as f:reader = PdfReader(f)text = ""for i, page in enumerate(reader.pages):page_text = page.extract_text()if page_text:text += page_textprint(f"  - 已提取第{i+1}頁")print(f"[PDF提取] 完成，總長度: {len(text)} 字符\n")return textdef chunk_text(text: str, n: int = 1000, overlap: int = 200) -> List[str]:"""將文本分割為帶重疊的塊。"""print(f"[分塊] 每塊{n}字符，重疊{overlap}字符")chunks = []for i in range(0, len(text), n - overlap):chunks.append(text[i:i + n])print(f"[分塊] 完成，共{len(chunks)}塊\n")return chunks# ========== 向量生成與存儲 ==========
def create_embeddings(texts, model: str = EMBEDDING_MODEL) -> List[np.ndarray]:"""用阿里embedding模型批量生成文本向量。支持單條或多條文本。"""if isinstance(texts, str):texts = [texts]print(f"[嵌入生成] 正在生成{len(texts)}條文本的向量...")try:response = TextEmbedding.call(model=model,input=texts,api_key=ALI_API_KEY)if response.status_code == 200:embeddings = [np.array(item['embedding']) for item in response.output['embeddings']]print(f"[嵌入生成] 成功，返回{len(embeddings)}條向量\n")return embeddings if len(embeddings) > 1 else embeddings[0]else:print(f"[嵌入生成] 失敗: {response.message}")return [np.zeros(1536)] * len(texts)except Exception as e:print(f"[嵌入生成] 異常: {e}")return [np.zeros(1536)] * len(texts)class SimpleVectorStore:"""簡單的向量存儲與檢索類。"""def __init__(self):self.vectors = []self.texts = []self.metadata = []def add_item(self, text, embedding, metadata=None):self.vectors.append(np.array(embedding))self.texts.append(text)self.metadata.append(metadata or {})def similarity_search(self, query_embedding, k=5):if not self.vectors:return []query_vector = np.array(query_embedding)similarities = []for i, vector in enumerate(self.vectors):sim = np.dot(query_vector, vector) / (np.linalg.norm(query_vector) * np.linalg.norm(vector))similarities.append((i, sim))similarities.sort(key=lambda x: x[1], reverse=True)results = []for i in range(min(k, len(similarities))):idx, score = similarities[i]results.append({"text": self.texts[idx],"metadata": self.metadata[idx],"similarity": score})return results# ========== 文檔處理主流程 ==========
def process_document(pdf_path: str, chunk_size: int = 1000, chunk_overlap: int = 200) -> SimpleVectorStore:"""處理PDF文檔，提取文本、分塊、生成向量并構建向量庫。"""print("[主流程] 開始處理文檔...")extracted_text = extract_text_from_pdf(pdf_path)text_chunks = chunk_text(extracted_text, chunk_size, chunk_overlap)print("[主流程] 初始化向量庫...")vector_store = SimpleVectorStore()print("[主流程] 為每個塊生成向量...")chunk_embeddings = create_embeddings(text_chunks)for i, (chunk, embedding) in enumerate(zip(text_chunks, chunk_embeddings)):print(f"[塊{i+1}/{len(text_chunks)}] 已生成向量，長度: {len(chunk)} 字符")vector_store.add_item(chunk, embedding, {"type": "chunk", "index": i})print("[主流程] 文檔處理完畢，向量庫構建完成\n")return vector_store# ========== LLM重排序 ==========
def rerank_with_llm(query: str, results: List[Dict], top_n: int = 3, model: str = LLM_MODEL) -> List[Dict]:"""使用LLM對初步檢索結果進行重排序。"""print(f"[重排序] 對{len(results)}個文檔進行LLM重排序...")scored_results = []system_prompt = "你是文檔相關性評估專家，請根據用戶問題對下列文檔相關性打分，0-10分，10分最相關。只返回分數，不要輸出其他內容。"for i, result in enumerate(results):if i % 5 == 0:print(f"[重排序] 正在評估第{i+1}/{len(results)}個文檔...")user_prompt = f"""問題: {query}\n\n文檔內容:\n{result['text']}\n\n請對該文檔與問題的相關性打分（0-10分）："""try:response = Generation.call(model=model,messages=[{"role": "system", "content": system_prompt},{"role": "user", "content": user_prompt}],api_key=ALI_API_KEY,result_format='message')score_text = response.output.choices[0].message.content.strip()score_match = re.search(r'\b(10|[0-9])\b', score_text)if score_match:score = float(score_match.group(1))else:print(f"[重排序] 警告: 無法提取分數，使用相似度分數代替: '{score_text}'")score = result["similarity"] * 10except Exception as e:print(f"[重排序] LLM調用異常: {e}，使用相似度分數代替")score = result["similarity"] * 10scored_results.append({"text": result["text"],"metadata": result["metadata"],"similarity": result["similarity"],"relevance_score": score})reranked_results = sorted(scored_results, key=lambda x: x["relevance_score"], reverse=True)print(f"[重排序] 完成，返回Top{top_n}結果\n")return reranked_results[:top_n]# ========== 關鍵詞重排序 ==========
def rerank_with_keywords(query: str, results: List[Dict], top_n: int = 3) -> List[Dict]:"""使用關鍵詞匹配對初步檢索結果進行簡單重排序。"""print(f"[關鍵詞重排序] 對{len(results)}個文檔進行關鍵詞重排序...")keywords = [word.lower() for word in query.split() if len(word) > 3]scored_results = []for result in results:document_text = result["text"].lower()base_score = result["similarity"] * 0.5keyword_score = 0for keyword in keywords:if keyword in document_text:keyword_score += 0.1first_position = document_text.find(keyword)if first_position < len(document_text) / 4:keyword_score += 0.1frequency = document_text.count(keyword)keyword_score += min(0.05 * frequency, 0.2)final_score = base_score + keyword_scorescored_results.append({"text": result["text"],"metadata": result["metadata"],"similarity": result["similarity"],"relevance_score": final_score})reranked_results = sorted(scored_results, key=lambda x: x["relevance_score"], reverse=True)print(f"[關鍵詞重排序] 完成，返回Top{top_n}結果\n")return reranked_results[:top_n]# ========== 回答生成 ==========
def generate_response(query: str, context: str, model: str = LLM_MODEL) -> str:"""用大模型基于上下文生成回答。"""print("[生成] 正在調用大模型生成回答...")system_prompt = "你是一個AI助手，只能基于給定上下文回答問題。如果上下文無法直接回答，請回復：'信息不足，無法回答。'"user_prompt = f"""
上下文：\n{context}\n\n問題：{query}\n\n請只基于上述上下文簡明準確作答。"""try:response = Generation.call(model=model,messages=[{"role": "system", "content": system_prompt},{"role": "user", "content": user_prompt}],api_key=ALI_API_KEY,result_format='message')answer = response.output.choices[0].message.content.strip()print(f"[生成] 回答生成成功: {answer}\n")return answerexcept Exception as e:print(f"[生成] 回答生成異常: {e}")return ""# ========== RAG主流程 ==========
def rag_with_reranking(query: str, vector_store: SimpleVectorStore, reranking_method: str = "llm", top_n: int = 3, model: str = LLM_MODEL) -> Dict:"""完整RAG流程，包含初步檢索、重排序和回答生成。"""print(f"[RAG] 開始RAG流程，檢索+重排序方法: {reranking_method}")query_embedding = create_embeddings(query)initial_results = vector_store.similarity_search(query_embedding, k=10)if reranking_method == "llm":reranked_results = rerank_with_llm(query, initial_results, top_n=top_n)elif reranking_method == "keywords":reranked_results = rerank_with_keywords(query, initial_results, top_n=top_n)else:reranked_results = initial_results[:top_n]context = "\n\n===\n\n".join([result["text"] for result in reranked_results])response = generate_response(query, context, model)print(f"[RAG] 流程完成\n")return {"query": query,"reranking_method": reranking_method,"initial_results": initial_results[:top_n],"reranked_results": reranked_results,"context": context,"response": response}# ========== main方法示例 ==========
if __name__ == "__main__":# 示例PDF路徑（請替換為實際文件）pdf_path = "data/2888年Java程序員找工作最新場景題.pdf"# 示例問題query = "Java程序員面試中常見的技術問題有哪些？"print("\n===== RAG重排序增強示例 =====\n")vector_store = process_document(pdf_path)print("[主流程] 向量庫已構建，開始不同重排序方法對比...\n")# 1. 標準檢索（無重排序）print("\n=== 標準檢索（無重排序） ===")standard_results = rag_with_reranking(query, vector_store, reranking_method="none")print(f"\nQuery: {query}")print(f"\nResponse:\n{standard_results['response']}")# 2. LLM重排序print("\n=== LLM重排序 ===")llm_results = rag_with_reranking(query, vector_store, reranking_method="llm")print(f"\nQuery: {query}")print(f"\nResponse:\n{llm_results['response']}")# 3. 關鍵詞重排序print("\n=== 關鍵詞重排序 ===")keyword_results = rag_with_reranking(query, vector_store, reranking_method="keywords")print(f"\nQuery: {query}")print(f"\nResponse:\n{keyword_results['response']}")