Премини към основното съдържание
Български— Изберете език
Меню

Пълен RAG конвейер

Урок 14 от 18 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Сглобяване на цялостната картина
  2. Пълният конвейер
  3. Стартиране на конвейера
  4. Пет направления за по-нататъшно подобрение
  5. Ключови изводи

Сглобяване на цялостната картина

Предишните уроци разгледаха всяка връзка във веригата поотделно: зареждане, разделяне на части (chunking), кодиране, индексиране, извличане и генериране. Сега е време да ги свържете в една цялостна, край до край програма, която можете да стартирате веднага и след това да адаптирате към собствените си документи. Този скрипт се събира в един файл и изисква само четири зависимости.

pip install mistralai faiss-cpu numpy requests

Пълният конвейер

Две дизайнерски решения структурират този код. Първо, групираме цялата конфигурация в началото на файла: моделите, размерът на частите, размерът на партидата и TOP_K са именувани константи. Това Ви спестява търсенето на твърдо кодирани стойности, заровени във функциите, когато трябва да настроите поведението. Второ, разделяме логиката на шест независими функции, всяка от които съответства на една стъпка и отпечатва напредъка си като [n/6]. Този проследяващ изход не е декоративен: когато конвейерът се провали или върне странен отговор, той Ви казва незабавно дали проблемът е в зареждането, разделянето на части или извличането. Всяка функция може също да бъде заменена изолирано – можете да включите зареждач за PDF вместо load_data, без да пипате останалата част.

Функцията main свързва стъпките една след друга, след което задава въпроси към корпуса с три въпроса относно есето на Пол Греъм, използвано като наш демонстрационен набор от данни. Обърнете внимание, че извличането и генерирането се изпълняват вътре в цикъла, докато индексирането се случва само веднъж предварително: повторното кодиране на целия корпус за всеки въпрос би било абсурдно както от гледна точка на разходите, така и на латентността.

import os
import json
import numpy as np
import faiss
import requests
from mistralai.client import Mistral

# ============================================================
# Configuration
# ============================================================
MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
EMBED_MODEL = "mistral-embed"
CHAT_MODEL = "mistral-large-latest"
CHUNK_SIZE = 2048
BATCH_SIZE = 25
TOP_K = 3

client = Mistral(api_key=MISTRAL_API_KEY)


# ============================================================
# Step 1: Load Data
# ============================================================
def load_data(url):
    """Load a text document from a URL."""
    print("[1/6] Loading data...")
    response = requests.get(url)
    response.raise_for_status()
    text = response.text
    print(f"  -> {len(text)} characters loaded")
    return text


# ============================================================
# Step 2: Create Chunks
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
    """Split text into chunks."""
    print("[2/6] Creating chunks...")
    chunks = []
    paragraphs = text.split("\n\n")
    current = ""

    for para in paragraphs:
        para = para.strip()
        if not para:
            continue
        if len(current) + len(para) + 2 <= chunk_size:
            current = current + "\n\n" + para if current else para
        else:
            if current:
                chunks.append(current)
            current = para

    if current:
        chunks.append(current)

    print(f"  -> {len(chunks)} chunks created (avg size: {sum(len(c) for c in chunks) // len(chunks)} chars)")
    return chunks


# ============================================================
# Step 3: Generate Embeddings
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
    """Encode chunks into embeddings via mistral-embed."""
    print("[3/6] Generating embeddings...")
    all_embeddings = []

    for i in range(0, len(chunks), batch_size):
        batch = chunks[i:i + batch_size]
        response = client.embeddings.create(
            model=EMBED_MODEL,
            inputs=batch,
        )
        all_embeddings.extend([d.embedding for d in response.data])
        print(f"  -> Batch {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1} encoded")

    embeddings = np.array(all_embeddings, dtype=np.float32)
    print(f"  -> Matrix: {embeddings.shape}")
    return embeddings


# ============================================================
# Step 4: Create FAISS Index
# ============================================================
def create_index(embeddings):
    """Create and populate a FAISS index."""
    print("[4/6] Creating FAISS index...")
    dimension = embeddings.shape[1]
    index = faiss.IndexFlatL2(dimension)
    index.add(embeddings)
    print(f"  -> Index: {index.ntotal} vectors, dimension {dimension}")
    return index


# ============================================================
# Step 5: Retrieve Relevant Chunks
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
    """Retrieve the most relevant chunks."""
    print(f"[5/6] Searching for: '{question[:50]}...'")
    response = client.embeddings.create(
        model=EMBED_MODEL,
        inputs=[question],
    )
    query_vector = np.array([response.data[0].embedding], dtype=np.float32)

    distances, indices = index.search(query_vector, k)

    results = []
    for dist, idx in zip(distances[0], indices[0]):
        if idx >= 0:
            results.append({
                "text": chunks[idx],
                "distance": float(dist),
            })

    print(f"  -> {len(results)} chunks retrieved")
    return results


# ============================================================
# Step 6: Generate Answer
# ============================================================
def generate(question, context_chunks):
    """Generate the answer using retrieved context."""
    print("[6/6] Generating answer...")

    context = "\n\n---\n\n".join([c["text"] for c in context_chunks])

    prompt = f"""Informative context:

{context}

---

Based ONLY on the context above, answer the following question precisely and completely.

Question: {question}"""

    response = client.chat.complete(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": "You are an assistant that answers based on the provided context."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.1,
    )

    answer = response.choices[0].message.content
    print(f"  -> Answer generated ({len(answer)} characters)")
    return answer


# ============================================================
# Main Pipeline
# ============================================================
def main():
    """Run the complete RAG pipeline."""
    # 1. Load
    url = "https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt"
    text = load_data(url)

    # 2. Chunk
    chunks = create_chunks(text)

    # 3. Encode
    embeddings = create_embeddings(chunks)

    # 4. Index
    index = create_index(embeddings)

    # 5+6. Question -> Answer
    questions = [
        "What were the two main things the author worked on before college?",
        "What did the author do during their time at Y Combinator?",
        "What programming language did the author learn first?",
    ]

    for question in questions:
        print(f"\n{'='*60}")
        context = retrieve(question, index, chunks)
        answer = generate(question, context)
        print(f"\nQ: {question}")
        print(f"A: {answer}")


if __name__ == "__main__":
    main()

Стартиране на конвейера

Запазете този код като rag_pipeline.py, експортирайте Вашия API ключ в средата – никога не го кодирайте твърдо във файла, тъй като в крайна сметка той ще попадне в хранилище – и след това стартирайте скрипта. Изходът преминава през шестте стъпки, след което обработва трите въпроса с техните отговори. Ако някой отговор изглежда извън темата, сравнете го с частите, показани в стъпка 5, преди да обвините модела за генериране.

export MISTRAL_API_KEY="your-api-key"
python rag_pipeline.py

Пет направления за по-нататъшно подобрение

Този конвейер е фундамент, а не готов продукт, и всяко от неговите ограничения сочи към следваща стъпка. Най-непосредственото е постоянството: в настоящата си форма скриптът прекодира целия корпус при всяко изпълнение, докато запазването на FAISS индекса и частите би направило последващите изпълнения почти мигновени. Повторното класиране (re-ranking) е следващото ниво, което предава резултатите от FAISS през кръстосан енкодер (cross-encoder), който преценява релевантността много по-фино от самото векторно разстояние. Филтрирането по метаданни адресира друга нужда: ограничаване на търсенето по дата, категория или автор в допълнение към сходството. Две последни подобрения се фокусират върху потребителското изживяване: потоково предаване (streaming), което показва отговора, докато се генерира, вместо след няколко секунди тишина, и история на разговора, която позволява на потребителите да задават последващи въпроси като „а какво ще кажете за версия 2?“, без да преразказват целия си въпрос.

# 1. Save the index to avoid recalculating
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))

# 2. Add re-ranking
# After FAISS retrieval, use a cross-encoder model
# to re-order results by fine-grained relevance

# 3. Metadata filtering
# Add filters (date, category, author) in addition
# to vector similarity

# 4. Response streaming
# Use client.chat.stream() to display the answer
# as it generates

# 5. Conversation history
# Add previous exchanges to the prompt
# for a contextual RAG chatbot

Ключови изводи

  • Пълният RAG конвейер се разпада на 6 стъпки: зареждане, разделяне на части, кодиране, индексиране, извличане, генериране
  • Всяка стъпка е независима функция, лесна за тестване и замяна
  • Използвайте temperature=0.1 за фактологични отговори
  • Запазете FAISS индекса и вгражданията, за да избегнете преизчисляване при всяко изпълнение
  • Този конвейер е солидна отправна точка за обогатяване според Вашите нужди