0Pricing
LLM Apps in Production (RAG + Vector DB + Caching) · 강의

질의 재작성과 재순위화

사용자 질의를 최적화하고 검색된 문서의 순위를 다시 매겨 LLM과의 관련성을 높이는 기법을 살펴봅니다.

질의 재작성과 재순위화은(는) CoddyKit의 무료 LLM Apps in Production (RAG + Vector DB + Caching) 강의입니다. 이것은 4개 중 1번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 LLM Apps in Production (RAG + Vector DB + Caching) 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. LLM Apps in Production (RAG + Vector DB + Caching) 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Optimizing Queries for RAG

Welcome to advanced RAG techniques! In this lesson, we'll explore two powerful methods to make your Retrieval Augmented Generation (RAG) system even smarter: Query Rewriting and Reranking.

These techniques help ensure your LLM gets the most relevant information possible, leading to better and more accurate responses.

Why Raw Queries Fall Short

When a user asks a question, their initial query might not be perfect for searching your knowledge base. It could be:

  • Too short or vague: Lacking specific keywords.
  • Ambiguous: Having multiple possible meanings.
  • Missing synonyms: Not using the exact terms found in your documents.

This can lead to your retriever fetching less relevant documents.

Understanding Query Rewriting

Query rewriting is the process of modifying the user's original query before it's sent to your document retriever.

The goal is to transform the query into a more effective search term that is more likely to match relevant documents in your vector database.

Techniques for Rewriting Queries

Query rewriting can involve several strategies:

  • Query Expansion: Adding synonyms or related terms to broaden the search.
  • Query Rephrasing: Changing the query's structure or wording to improve clarity.
  • Query Decomposition: Breaking a complex, multi-part query into simpler, individual sub-queries.

Often, another LLM is used to perform these rewriting tasks.

Code: Simple Query Rewriting

Here's a conceptual Python example of how a simple query expansion might work. In a real system, an LLM would do the heavy lifting.

class QueryRewriter:
    def rewrite(self, query):
        # Simulate an LLM or a rule-based system
        if "LLM performance" in query:
            return query + " large language model efficiency optimization"
        if "vector db" in query:
            return query + " vector database semantic search"
        return query

rewriter = QueryRewriter()
user_query_1 = "improve LLM performance"
rewritten_1 = rewriter.rewrite(user_query_1)
print(f"Original 1: {user_query_1}")
print(f"Rewritten 1: {rewritten_1}\n")

user_query_2 = "how to use vector db"
rewritten_2 = rewriter.rewrite(user_query_2)
print(f"Original 2: {user_query_2}")
print(f"Rewritten 2: {rewritten_2}")

Why We Need Reranking

Even after a great initial search (perhaps with a rewritten query!), the top 'N' documents returned by your retriever might not be perfectly ordered by relevance.

The retriever's job is often to find potential matches. Reranking steps in to refine this order, ensuring the absolute best documents are at the very top.

The Reranking Process

Reranking works like this:

  1. Your initial retriever fetches a larger set of candidate documents (e.g., top 50).
  2. A specialized reranker model then takes each of these candidate documents, along with the original user query, and provides a more precise relevance score.
  3. The documents are then sorted again based on these new, more accurate scores.

This ensures the most relevant documents are passed to the LLM.

Specialized Reranking Models

Unlike a retriever that often uses embeddings for approximate similarity, rerankers typically use more sophisticated models, often called cross-encoders.

  • Cross-encoders take both the query AND a document as input.
  • They consider the interaction between the query and document terms directly.
  • This allows for a much more nuanced understanding of relevance, though it's computationally more intensive, hence why it's only applied to a smaller subset of documents.

Code: Simulating Reranking

This example shows how a reranker might re-score and reorder an initially retrieved list of documents based on their relevance to the query.

class Reranker:
    def rerank(self, query, documents):
        # Simulate a cross-encoder model scoring documents
        scores = {}
        for doc in documents:
            if "vector database" in doc.lower() and "fast" in query.lower():
                scores[doc] = 0.95 # Highly relevant
            elif "llm" in doc.lower() and "improve" in query.lower():
                scores[doc] = 0.85
            elif "database" in doc.lower():
                scores[doc] = 0.7
            else:
                scores[doc] = 0.3 # Less relevant
        
        # Sort documents by score in descending order
        sorted_docs = sorted(documents, key=lambda d: scores.get(d, 0), reverse=True)
        return sorted_docs

reranker = Reranker()
user_query = "How to build a fast vector database?"
initial_docs = [
    "Introduction to LLMs",
    "Building a scalable vector database",
    "Optimizing LLM inference",
    "Fast data ingestion for databases"
]

reranked_docs = reranker.rerank(user_query, initial_docs)
print(f"Original documents: {initial_docs}\n")
print("Reranked documents (most relevant first):")
for doc in reranked_docs:
    print(f"- {doc}")

The Power of Combination

The true power comes from combining both techniques:

  • First, Query Rewriting creates a better search query.
  • Then, your retriever uses this improved query to fetch a broader, more relevant set of documents.
  • Finally, Reranking fine-tunes the order of these documents, ensuring the LLM receives the absolute best context to generate a response.

This multi-stage approach significantly boosts the quality and accuracy of your RAG system.

Check Your Understanding

Time to test what you've learned about optimizing RAG through query rewriting and reranking.

Recap & Next Steps

Great job! In this lesson, you learned about Query Rewriting and Reranking.

  • Query Rewriting modifies the user's input to create a more effective search query.
  • Reranking reorders initially retrieved documents using a more precise model to surface the most relevant ones.

Together, these techniques significantly enhance the quality and accuracy of your RAG applications. Next, we'll explore even more advanced RAG architectures!

자주 묻는 질문

“질의 재작성과 재순위화” 강의는 무료인가요?

네 — “질의 재작성과 재순위화” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 LLM Apps in Production (RAG + Vector DB + Caching) 강의 전체를 잠금 해제할 수 있습니다. LLM Apps in Production (RAG + Vector DB + Caching) 강의에는 총 4개의 강의가 포함되어 있습니다.

“질의 재작성과 재순위화”에서 뭘 배우나요?

사용자 질의를 최적화하고 검색된 문서의 순위를 다시 매겨 LLM과의 관련성을 높이는 기법을 살펴봅니다. 브라우저에서 직접 실행하는 실습 코드로 LLM Apps in Production (RAG + Vector DB + Caching)을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

LLM Apps in Production (RAG + Vector DB + Caching)을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 LLM Apps in Production (RAG + Vector DB + Caching)은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 1번째 강의입니다.

“질의 재작성과 재순위화” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 LLM Apps in Production (RAG + Vector DB + Caching) 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 LLM Apps in Production (RAG + Vector DB + Caching) 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

  1. 질의 재작성과 재순위화
  2. 다단계 및 에이전트 기반 RAG 패턴
  3. 복잡한 문서 구조 처리하기
  4. 자기 질의 및 인용
← LLM Apps in Production (RAG + Vector DB + Caching)(으)로 돌아가기