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

Пълна архитектура на RAG

Урок 11 от 22 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Цели
  2. Какво е RAG?
  3. Етапи на конвейера
  4. Пълна реализация
  5. Употреба
  6. Точки за оптимизация
  7. Ключови изводи

Урокът е актуализиран на 3 ноември 2026 г. въз основа на документацията на OpenAI: параметрите temperature и top_p се приемат само при усилие за разсъждение (reasoning effort) от none, докато моделите GPT-5.6 разсъждават по подразбиране (medium). Заявките, които задават тези параметри, следователно трябва да уточняват reasoning={"effort": "none"} (API Responses) или reasoning_effort="none" (Chat Completions). Източници: Използване на GPT-6 · GPT-5.6 Terra.

Цели

  • Да разберете архитектурата на RAG от край до край
  • Да внедрите функционален RAG конвейер (pipeline)
  • Да идентифицирате компонентите за оптимизация

Какво е RAG?

RAG (Retrieval-Augmented Generation – Генериране, подпомогнато от извличане) комбинира търсенето на документи с генерирането на текст от голям езиков модел (LLM). Вместо да разчита единствено на вътрешните си знания, моделът получава съответни документи като контекст и след това изготвя отговора си въз основа на този контекст. Всичко, което сте изградили от началото на този курс – вграждания (embeddings), индексиране, търсене, оценка – тук се превръща в горната половина на една цялостна система.

Защо RAG?

Четири причини го обосновават и те се подсилват взаимно. Първо, собствени данни: вашата политика за дистанционна работа, вътрешните процедури и продуктовият каталог никога не са се появявали в обучаващите данни на модела и никакъв промпт не може да ги появи там. Второ, скорошна информация: всичко, което е след датата на обучението, е невидимо за модела, докато един индекс може да се актуализира в същия ден. Проверяемостта е също толкова важна, защото всеки отговор е закрепен към идентифицируеми източници, които потребителят може да отвори и провери – това променя същността на доверието, възлагано на системата. Накрая, разходите работят в негова полза: добавянето на знания чрез RAG струва много по-малко от фина настройка (fine-tuning), а корекциите стават чрез изтриване на документ, а не чрез повторно обучение на модел.

Етапи на конвейера

Разглеждайте RAG на два отделни етапа, които не бива да бъркате. Поглъщането (Ingestion) се извършва офлайн, веднъж завинаги или винаги когато корпусът се актуализира:

Documents → Chunking → Embeddings → Vector Storage

Заявката (Query) се случва онлайн, за всеки зададен въпрос, и трябва да остане бърза:

Question → Embedding → Search → Context + Question → LLM → Response

Това разделение има практическо следствие: разходите за поглъщане се плащат веднъж и могат да бъдат значителни, докато разходите за заявка се плащат на повикване и диктуват потребителското изживяване. Следователно можете да си позволите сложна обработка при поглъщането, но трябва да останете леки откъм страната на заявките.

Пълна реализация

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

from openai import OpenAI
import numpy as np

client = OpenAI()

class PipelineRAG:
    def __init__(
        self,
        model_embedding: str = "text-embedding-3-large",
        model_generation: str = "gpt-5.6-terra"
    ):
        self.client = OpenAI()
        self.model_embedding = model_embedding
        self.model_generation = model_generation
        self.chunks: list[dict] = []
        self.embeddings: np.ndarray | None = None

    # --- Ingestion Phase ---

    def ingest(self, documents: list[dict]):
        """Ingests documents {id, text, metadata}."""
        self.chunks = documents
        texts = [d["text"] for d in documents]

        # Generate embeddings in batches
        all_emb = []
        for i in range(0, len(texts), 100):
            batch = texts[i:i + 100]
            resp = self.client.embeddings.create(
                input=batch, model=self.model_embedding
            )
            batch_emb = sorted(resp.data, key=lambda x: x.index)
            all_emb.extend([e.embedding for e in batch_emb])

        self.embeddings = np.array(all_emb, dtype=np.float32)
        print(f"Ingestion complete: {len(self.chunks)} chunks indexed")

    # --- Retrieval Phase ---

    def search(self, question: str, k: int = 5) -> list[dict]:
        """Finds the k most relevant chunks."""
        query_emb = self.client.embeddings.create(
            input=question, model=self.model_embedding
        ).data[0].embedding

        scores = self.embeddings @ np.array(query_emb)
        top_k = np.argsort(scores)[-k:][::-1]

        return [
            {**self.chunks[i], "score": float(scores[i])}
            for i in top_k
        ]

    # --- Generation Phase ---

    def generate(self, question: str, contexts: list[dict]) -> str:
        """Generates a response based on retrieved contexts."""
        # Build the prompt
        formatted_context = "\n\n---\n\n".join(
            f"[Source: {c.get('id', 'unknown')}]\n{c['text']}"
            for c in contexts
        )

        messages = [
            {
                "role": "system",
                "content": (
                    "You are an assistant that answers questions "
                    "based solely on the provided documents. "
                    "If the information is not in the documents, "
                    "state this clearly. Cite your sources."
                )
            },
            {
                "role": "user",
                "content": (
                    f"Reference documents:\n\n{formatted_context}\n\n"
                    f"---\n\nQuestion: {question}"
                )
            }
        ]

        response = self.client.chat.completions.create(
            model=self.model_generation,
            reasoning_effort="none",  # temperature requires effort none
            messages=messages,
            temperature=0.2
        )

        return response.choices[0].message.content

    # --- Complete Pipeline ---

    def answer(self, question: str, k: int = 5) -> dict:
        """Complete RAG pipeline: search → generation."""
        contexts = self.search(question, k=k)
        response = self.generate(question, contexts)

        return {
            "question": question,
            "response": response,
            "sources": [
                {"id": c["id"], "score": c["score"],
                 "excerpt": c["text"][:150]}
                for c in contexts
            ]
        }

Три детайла във фазата на генериране движат по-голямата част от качеството. Системното съобщение задължава отговарянето единствено въз основа на предоставените документи и признаването, когато информация липсва: без тази инструкция моделът ще запълни пропуските със своите общи знания, което води до правдоподобен, но измислен отговор. Префиксът [Source: id] преди всеки откъс дава на модела нещо конкретно, което да цитира, вместо неясното „според документите“. Накрая, temperature от 0.2 намалява вариативността: за фактологични въпроси спрямо база документи искате последователност, а не креативност.

Употреба

Нека тестваме конвейера върху минимален бизнес случай – три вътрешни политики и въпрос, който не копира нито една от техните точни формулировки.

# Prepare documents
documents = [
    {
        "id": "leave-policy",
        "text": "Employees receive 25 days of paid leave "
                 "per year. Leave must be requested at least 2 weeks "
                 "in advance via the HR portal.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "remote-work-policy",
        "text": "Remote work is authorized up to 3 days per week. "
                 "Tuesdays and Thursdays are mandatory office days. "
                 "Written agreement with the manager is required.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "reimbursement-procedure",
        "text": "Expense reports must be submitted within 30 days "
                 "of the expense. Attach the original receipt. "
                 "Validation by the direct supervisor required for amounts over 200 euros.",
        "metadata": {"type": "finance", "date": "2026-01"}
    },
]

# Create the pipeline
rag = PipelineRAG()
rag.ingest(documents)

# Ask a question
result = rag.answer("How many days of remote work per week?")
print(result["response"])
print("\nSources used:")
for s in result["sources"]:
    print(f"  [{s['score']:.3f}] {s['id']}: {s['excerpt']}")

Разширете упражнението, като зададете въпрос, на който никой документ не отговаря, например такъв за здравното осигуряване в компанията. Конвейерът все пак ще върне три източника – търсенето винаги връща своите k най-добри кандидати – и именно системното съобщение трябва да предотврати измислянето на отговор от модела. Проверката на това поведение преди пускане в продукция е по-добре от откриването му чрез жалба.

Точки за оптимизация

Всеки етап от конвейера може да бъде подобрен независимо, което позволява напредък чрез малки, измерими промени.

ЕтапВъзможни оптимизации
ChunkingРазмер на чънка, припокриване, семантично разделяне
EmbeddingИзбор на модел, измерения, обогатяване на текста
SearchХибридно търсене, преподреждане (reranking), филтри по метаданни
PromptСистемни инструкции, формат на контекста, few-shot примери
GenerationМодел, температура, цитиране

Следващите уроци детайлизират всяка от тези оптимизации. Подходете към тях в този ред: разделянето на чънкове определя какво може да бъде извлечено и никакво преподреждане няма да оправи лошо разделен документ.

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

  • RAG = Търсене + Контекст + Генериране от LLM
  • Конвейерът се разделя на поглъщане (офлайн) и заявка (онлайн)
  • Всеки компонент (разделяне на чънкове, вграждане, търсене, промпт, генериране) може да се оптимизира независимо
  • RAG е по-гъвкав и по-евтин от фина настройка (fine-tuning) за добавяне на знания