如何建構 RAG 應用程式：從原型到生產環境 [2026]

pip install openai numpy

export OPENAI_API_KEY="sk-your-key-here"

import os

def load_documents(directory: str) -> list[dict]:
    """Load all .txt and .md files from a directory."""
    documents = []
    for filename in os.listdir(directory):
        if filename.endswith(('.txt', '.md')):
            with open(os.path.join(directory, filename), 'r') as f:
                documents.append({
                    'content': f.read(),
                    'source': filename
                })
    return documents

docs = load_documents('./knowledge_base')
print(f"Loaded {len(docs)} documents")

def chunk_text(text: str, chunk_size: int = 500, overlap: int = 50) -> list[str]:
    """Split text into overlapping chunks by character count."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunks.append(text[start:end])
        start = end - overlap
    return chunks

all_chunks = []
chunk_metadata = []

for doc in docs:
    chunks = chunk_text(doc['content'])
    for i, chunk in enumerate(chunks):
        all_chunks.append(chunk)
        chunk_metadata.append({'source': doc['source'], 'chunk_index': i})

print(f"Created {len(all_chunks)} chunks from {len(docs)} documents")

from openai import OpenAI
import numpy as np

client = OpenAI()

def get_embeddings(texts: list[str], model: str = "text-embedding-3-small") -> np.ndarray:
    """Generate embeddings for a list of texts."""
    response = client.embeddings.create(input=texts, model=model)
    return np.array([item.embedding for item in response.data])

# Embed all chunks (batch for efficiency)
chunk_embeddings = get_embeddings(all_chunks)
print(f"Embeddings shape: {chunk_embeddings.shape}")
# Output: Embeddings shape: (142, 1536)

def cosine_similarity(a: np.ndarray, b: np.ndarray) -> np.ndarray:
    """Compute cosine similarity between vector a and matrix b."""
    return np.dot(b, a) / (np.linalg.norm(b, axis=1) * np.linalg.norm(a))

def retrieve(query: str, top_k: int = 5) -> list[dict]:
    """Find the top-k most relevant chunks for a query."""
    query_embedding = get_embeddings([query])[0]
    similarities = cosine_similarity(query_embedding, chunk_embeddings)
    top_indices = np.argsort(similarities)[-top_k:][::-1]

    results = []
    for idx in top_indices:
        results.append({
            'content': all_chunks[idx],
            'score': float(similarities[idx]),
            'metadata': chunk_metadata[idx]
        })
    return results

results = retrieve("How does the billing system work?")
for r in results:
    print(f"[{r['score']:.3f}] {r['metadata']['source']}: {r['content'][:80]}...")

def generate_answer(query: str, context_chunks: list[dict]) -> str:
    """Generate an answer using retrieved context."""
    context = "\n\n---\n\n".join([c['content'] for c in context_chunks])

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a helpful assistant. Answer the user's question "
                    "based ONLY on the provided context. If the context doesn't "
                    "contain the answer, say so. Cite which source document you "
                    "used."
                )
            },
            {
                "role": "user",
                "content": f"Context:\n{context}\n\nQuestion: {query}"
            }
        ],
        temperature=0.1
    )
    return response.choices[0].message.content

# Put it all together
query = "How does the billing system work?"
chunks = retrieve(query, top_k=5)
answer = generate_answer(query, chunks)
print(answer)

pip install rank-bm25

from rank_bm25 import BM25Okapi
import numpy as np

class HybridRetriever:
    def __init__(self, chunks: list[str], embeddings: np.ndarray):
        # BM25 index over tokenised chunks
        tokenised = [chunk.lower().split() for chunk in chunks]
        self.bm25 = BM25Okapi(tokenised)
        self.chunks = chunks
        self.embeddings = embeddings  # shape: (n_chunks, embed_dim)

    def retrieve(self, query: str, query_embedding: np.ndarray, top_k: int = 20) -> list[dict]:
        # --- BM25 scores ---
        bm25_scores = self.bm25.get_scores(query.lower().split())
        bm25_ranking = np.argsort(bm25_scores)[::-1]

        # --- Vector scores (cosine similarity) ---
        norms = np.linalg.norm(self.embeddings, axis=1) * np.linalg.norm(query_embedding)
        vector_scores = np.dot(self.embeddings, query_embedding) / (norms + 1e-10)
        vector_ranking = np.argsort(vector_scores)[::-1]

        # --- Reciprocal Rank Fusion ---
        k = 60
        rrf_scores: dict[int, float] = {}
        for rank, idx in enumerate(vector_ranking):
            rrf_scores[idx] = rrf_scores.get(idx, 0) + 1 / (k + rank + 1)
        for rank, idx in enumerate(bm25_ranking):
            rrf_scores[idx] = rrf_scores.get(idx, 0) + 1 / (k + rank + 1)

        top_ids = sorted(rrf_scores, key=lambda i: rrf_scores[i], reverse=True)[:top_k]
        return [{"id": i, "content": self.chunks[i], "score": rrf_scores[i]} for i in top_ids]

# Usage
retriever = HybridRetriever(all_chunks, chunk_embeddings)
query_emb = get_embeddings([query])[0]
hybrid_results = retriever.retrieve(query, query_emb, top_k=20)

pip install cohere

import cohere

co = cohere.Client("your-cohere-api-key")

def rerank(query: str, candidates: list[dict], top_n: int = 5) -> list[dict]:
    """Rerank retrieved candidates with Cohere Rerank."""
    docs = [c["content"] for c in candidates]
    response = co.rerank(
        model="rerank-english-v3.0",
        query=query,
        documents=docs,
        top_n=top_n,
    )
    return [
        {**candidates[r.index], "rerank_score": r.relevance_score}
        for r in response.results
    ]

# After hybrid retrieval, rerank the top-20 down to 5
candidates = retriever.retrieve(query, query_emb, top_k=20)
final_chunks = rerank(query, candidates, top_n=5)

from sentence_transformers import CrossEncoder

bge_reranker = CrossEncoder("BAAI/bge-reranker-v2-m3")

def rerank_bge(query: str, candidates: list[dict], top_n: int = 5) -> list[dict]:
    pairs = [(query, c["content"]) for c in candidates]
    scores = bge_reranker.predict(pairs)
    ranked = sorted(zip(scores, candidates), reverse=True)
    return [c for _, c in ranked[:top_n]]

from ragas import evaluate
from ragas.metrics import (
    context_precision,
    context_recall,
    faithfulness,
    answer_relevancy,
)
from datasets import Dataset

# Build your evaluation dataset
# Golden Q&A pairs from domain experts
eval_data = {
    "question": [
        "How does the billing system work?",
        "What is the refund policy?",
    ],
    "answer": [
        # Your RAG system's actual answers
        "The billing system charges monthly...",
        "Refunds are available within 30 days...",
    ],
    "contexts": [
        # The chunks your system actually retrieved
        [["Billing is processed on the 1st of each month..."]],
        [["Our refund policy allows returns within 30 days..."]],
    ],
    "ground_truth": [
        # The correct answers (from domain experts)
        "Billing is monthly, charged on the 1st...",
        "Full refunds within 30 days of purchase...",
    ],
}

dataset = Dataset.from_dict(eval_data)
results = evaluate(
    dataset,
    metrics=[context_precision, context_recall, faithfulness, answer_relevancy],
)
print(results)
# {'context_precision': 0.85, 'context_recall': 0.78,
#  'faithfulness': 0.92, 'answer_relevancy': 0.88}

from openai import OpenAI
import json

client = OpenAI()

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "retrieve_context",
            "description": "Search the knowledge base for relevant information.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query to retrieve relevant chunks."}
                },
                "required": ["query"],
            },
        },
    }
]

def agentic_rag(user_question: str, max_steps: int = 3) -> str:
    """Agent decides when to retrieve and when it has enough context to answer."""
    messages = [
        {
            "role": "system",
            "content": (
                "You are a helpful assistant. Use the retrieve_context tool to look up "
                "information before answering. Retrieve as many times as needed, then "
                "give a final answer."
            ),
        },
        {"role": "user", "content": user_question},
    ]

    for _ in range(max_steps):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=TOOLS,
            tool_choice="auto",
        )
        msg = response.choices[0].message

        if msg.tool_calls:
            # Agent wants to retrieve more context
            for call in msg.tool_calls:
                args = json.loads(call.function.arguments)
                chunks = retrieve(args["query"], top_k=5)  # your retriever from earlier
                context_text = "\n".join(c["content"] for c in chunks)
                messages.append(msg)
                messages.append({
                    "role": "tool",
                    "tool_call_id": call.id,
                    "content": context_text,
                })
        else:
            # Agent is satisfied — return its final answer
            return msg.content

    return "Max retrieval steps reached without a final answer."

answer = agentic_rag(
    "How did our Q3 revenue compare to the previous year, and what drove the change?"
)
print(answer)