RAG với Pinecone + Claude — Vector database cho AI

Retrieval-Augmented Generation (RAG) là kỹ thuật kết hợp vector database với large language model để tạo ra hệ thống AI có khả năng trả lời dựa trên knowledge base riêng của bạn. Trong bài này, chúng ta sẽ xây dựng pipeline RAG hoàn chỉnh sử dụng Pinecone làm vector database và Claude làm AI engine.

Pinecone là managed vector database được tối ưu hóa cho similarity search — lý tưởng để lưu trữ embeddings và tìm kiếm semantic. Kết hợp với Claude, bạn có thể xây dựng chatbot biết kiến thức từ tài liệu nội bộ, support agent hiểu sản phẩm của bạn, hoặc search engine thông minh.

Kiến trúc tổng quan

Pipeline RAG với Pinecone + Claude gồm hai giai đoạn chính:

1. Indexing phase — Chuyển tài liệu thành embeddings, lưu vào Pinecone
2. Query phase — Nhận câu hỏi, tìm chunks liên quan, gửi context + câu hỏi cho Claude

Cài đặt môi trường

Trước tiên, cài đặt các thư viện cần thiết:

pip install anthropic pinecone-client voyageai

Tạo file .env với các API keys:

ANTHROPIC_API_KEY=your_anthropic_key
PINECONE_API_KEY=your_pinecone_key
VOYAGE_API_KEY=your_voyage_key

Bước 1: Khởi tạo Pinecone Index

Pinecone index là nơi lưu trữ tất cả vector embeddings. Mỗi vector đại diện cho một đoạn văn bản (chunk) từ tài liệu của bạn.

import os
from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key=os.environ.get("PINECONE_API_KEY"))

index_name = "claude-rag-demo"
dimension = 1024  # Voyage AI embedding dimension

# Tạo index nếu chưa tồn tại
if index_name not in pc.list_indexes().names():
    pc.create_index(
        name=index_name,
        dimension=dimension,
        metric="cosine",
        spec=ServerlessSpec(
            cloud="aws",
            region="us-east-1"
        )
    )

index = pc.Index(index_name)
print(f"Index ready: {index.describe_index_stats()}")

Bước 2: Tạo Embeddings với Voyage AI

Voyage AI cung cấp embeddings chất lượng cao, được tối ưu hóa để hoạt động tốt với Claude. Model voyage-3 cho dimension 1024, phù hợp cho hầu hết use cases.

import voyageai

voyage_client = voyageai.Client(api_key=os.environ.get("VOYAGE_API_KEY"))

def embed_texts(texts, input_type="document"):
    """
    Embed danh sách văn bản.
    input_type="document" cho indexing
    input_type="query" cho search
    """
    result = voyage_client.embed(
        texts,
        model="voyage-3",
        input_type=input_type
    )
    return result.embeddings

Tại sao cần phân biệt document vs query embedding?

Voyage AI tối ưu hóa embedding khác nhau cho document (văn bản dài, informative) và query (câu hỏi ngắn, intent-based). Sử dụng đúng input_type cải thiện độ chính xác của search đáng kể.

Bước 3: Chunking và Indexing tài liệu

Chunking là bước chia tài liệu dài thành các đoạn nhỏ để embed và lưu vào Pinecone. Kích thước chunk ảnh hưởng lớn đến chất lượng RAG.

import hashlib

def chunk_text(text, chunk_size=500, overlap=50):
    """Chia text thành chunks với overlap để giữ context."""
    words = text.split()
    chunks = []
    for i in range(0, len(words), chunk_size - overlap):
        chunk = " ".join(words[i:i + chunk_size])
        chunks.append(chunk)
    return chunks

def index_documents(documents):
    """
    documents: list of {"id": str, "text": str, "metadata": dict}
    """
    vectors = []
    for doc in documents:
        chunks = chunk_text(doc["text"])
        embeddings = embed_texts(chunks, input_type="document")

        for i, (chunk, embedding) in enumerate(zip(chunks, embeddings)):
            chunk_id = f"{doc['id']}_chunk_{i}"
            vectors.append({
                "id": chunk_id,
                "values": embedding,
                "metadata": {
                    **doc.get("metadata", {}),
                    "text": chunk,
                    "source_id": doc["id"],
                    "chunk_index": i
                }
            })

    # Upsert theo batch 100 vectors
    batch_size = 100
    for i in range(0, len(vectors), batch_size):
        batch = vectors[i:i + batch_size]
        index.upsert(vectors=batch)

    print(f"Indexed {len(vectors)} chunks from {len(documents)} documents")

Bước 4: Semantic Search

Khi người dùng hỏi câu hỏi, ta embed câu hỏi đó rồi tìm các chunks gần nhất trong Pinecone theo cosine similarity.

def search_similar(query, top_k=5, filter=None):
    """Tìm top_k chunks liên quan nhất với query."""
    query_embedding = embed_texts([query], input_type="query")[0]

    results = index.query(
        vector=query_embedding,
        top_k=top_k,
        include_metadata=True,
        filter=filter  # Optional: filter theo metadata
    )

    chunks = []
    for match in results.matches:
        chunks.append({
            "text": match.metadata.get("text", ""),
            "score": match.score,
            "source": match.metadata.get("source", "unknown"),
            "chunk_index": match.metadata.get("chunk_index", 0)
        })

    return chunks

Bước 5: Generate câu trả lời với Claude

Đây là bước cuối cùng — kết hợp retrieved context với câu hỏi, gửi cho Claude để tạo câu trả lời chính xác và có căn cứ.

import anthropic

claude_client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

def rag_answer(question, top_k=5):
    """Trả lời câu hỏi sử dụng RAG với Pinecone + Claude."""

    # Bước 1: Retrieve relevant chunks
    chunks = search_similar(question, top_k=top_k)

    if not chunks:
        return "Không tìm thấy thông tin liên quan trong knowledge base."

    # Bước 2: Format context
    context_parts = []
    for i, chunk in enumerate(chunks, 1):
        context_parts.append(
            f"[Nguồn {i} - Score: {chunk['score']:.3f}]
{chunk['text']}"
        )
    context = "

---

".join(context_parts)

    # Bước 3: Gọi Claude với context
    prompt = f"""Bạn là trợ lý AI thông minh. Dựa trên các đoạn văn bản được cung cấp dưới đây,
hãy trả lời câu hỏi của người dùng một cách chính xác và đầy đủ.
Nếu thông tin không đủ để trả lời, hãy thành thật nói rõ.

=== CONTEXT ===
{context}

=== CÂU HỎI ===
{question}"""

    response = claude_client.messages.create(
        model="claude-opus-4-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}]
    )

    return response.content[0].text

Ví dụ thực tế: Knowledge base sản phẩm

Hãy xem một ví dụ cụ thể — xây dựng chatbot hỗ trợ khách hàng dựa trên tài liệu sản phẩm:

# Index tài liệu sản phẩm
product_docs = [
    {
        "id": "faq-001",
        "text": """Claude API hỗ trợ nhiều ngôn ngữ lập trình bao gồm Python, JavaScript,
        TypeScript, Java, và Go. SDK chính thức được cung cấp cho Python và TypeScript.
        Các ngôn ngữ khác có thể sử dụng REST API trực tiếp...""",
        "metadata": {"source": "FAQ", "category": "technical"}
    },
    {
        "id": "pricing-001",
        "text": """Giá Claude API tính theo token. Input tokens và output tokens có mức giá
        khác nhau. Claude Haiku có giá thấp nhất, phù hợp cho ứng dụng high-volume.
        Claude Opus có giá cao hơn nhưng mạnh nhất cho complex reasoning...""",
        "metadata": {"source": "Pricing", "category": "business"}
    }
]

index_documents(product_docs)

# Test RAG
question = "Claude API hỗ trợ ngôn ngữ lập trình nào?"
answer = rag_answer(question)
print(answer)

Tối ưu hóa hiệu suất

1. Hybrid Search

Pinecone hỗ trợ hybrid search kết hợp dense vectors (semantic) với sparse vectors (keyword). Điều này cải thiện retrieval khi câu hỏi chứa tên riêng hoặc thuật ngữ kỹ thuật:

# Enable hybrid search khi tạo index
pc.create_index(
    name="hybrid-index",
    dimension=1024,
    metric="dotproduct",  # Dùng dotproduct cho hybrid
    spec=ServerlessSpec(cloud="aws", region="us-east-1")
)

2. Metadata Filtering

Filter kết quả theo metadata để tăng precision:

# Chỉ tìm trong documents thuộc category "technical"
chunks = search_similar(
    query="Cách tạo API key?",
    filter={"category": {"$eq": "technical"}}
)

3. Reranking

Sau khi retrieve top-20 chunks, dùng reranker để chọn ra top-5 chất lượng nhất trước khi gửi cho Claude. Voyage AI cũng cung cấp reranking API.

Monitoring và Evaluation

Một RAG system production cần được monitor liên tục:

• Retrieval precision — Các chunks được retrieve có thực sự liên quan không?
• Answer faithfulness — Claude có trả lời dựa trên context hay "hallucinate"?
• Latency — Tổng thời gian từ câu hỏi đến câu trả lời
• Cost per query — Embedding + Pinecone + Claude tokens

Kết luận

Bạn vừa xây dựng được một RAG pipeline hoàn chỉnh với Pinecone + Claude. Hệ thống này có thể scale lên hàng triệu documents nhờ Pinecone's managed infrastructure, trong khi Claude đảm bảo chất lượng câu trả lời cao.

Bước tiếp theo: Khám phá RAG với MongoDB + Claude để biết thêm về giải pháp self-hosted, hoặc đọc về Embeddings với Voyage AI để tối ưu hóa vector quality.

Bài viết liên quan

• RAG với MongoDB + Claude — Xây chatbot có kiến thức
• Contextual Retrieval — Nâng cấp RAG với embeddings ngữ cảnh
• LlamaIndex + Claude — RAG pipeline cơ bản
• Autonomous Coding Agent — AI tự viết code từ spec
• Claude cho Data: Khám phá dataset mới