Pilnīga RAG arhitektūra
Šajā lapā
Nodarbība atjaunināta 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri
temperatureuntop_ptiek pieņemti tikai tad, ja spriešanas piepūle (reasoning effort) ir iestatīta uznone, savukārt GPT-5.6 modeļi pēc noklusējuma veic spriešanu (medium). Tāpēc izsaukumos, kuros tiek iestatīti šie parametri, ir jānorādareasoning={"effort": "none"}(API Responses) vaireasoning_effort="none"(Chat Completions). Avoti: Using GPT-6 · GPT-5.6 Terra.
Mērķi
- Izprast pilnu RAG arhitektūru no sākuma līdz beigām
- Ieviest funkcionālu RAG darbplūsmu
- Identificēt komponentus optimizēšanai
Kas ir RAG?
RAG (Retrieval-Augmented Generation — meklēšanas papildināta ģenerēšana) apvieno dokumentu meklēšanu ar teksta ģenerēšanu, ko veic LLM. Tā vietā, lai paļautos tikai uz savām iekšējām zināšanām, modelis saņem atbilstošus dokumentus kā kontekstu un pēc tam, balstoties uz šo kontekstu, formulē savu atbildi. Viss, ko esi izveidojis kopš šī kursa sākuma — iegultnes, indeksēšana, meklēšana, novērtēšana — šeit kļūst par pilnīgas sistēmas augšupplūsmas pusi.
Kāpēc RAG?
To attaisno četri iemesli, un tie summējas. Pirmkārt, privātie dati: tava attālinātā darba politika, iekšējās procedūras un produktu katalogs nekad nav bijuši modeļa apmācības datos, un neviena komanda tos tur neievietos. Otrkārt, jaunākā informācija: viss, kas radies pēc apmācības datu cutoff, modelim ir neredzams, savukārt indekss var tikt atjaunināts tajā pašā dienā. Tikpat svarīga ir pārbaudāmība, jo katra atbilde ir balstīta uz identificējamiem avotiem, kurus lietotājs var atvērt un pārbaudīt — tas maina sistēmai uzticēto attiecību dabu. Visbeidzot, izmaksas strādā par labu RAG: zināšanu pievienošana, izmantojot RAG, maksā daudz mazāk nekā smalkā noregulēšana (fine-tuning), un labojumus veic, dzēšot dokumentu, nevis pārapmācot modeli.
Darbplūsmas posmi
Uztver RAG kā divus atšķirīgus posmus, kurus nedrīkst jaukt. Ievade (Ingestion) notiek bezsaistē, vienreiz un uz visiem laikiem vai ikreiz, kad datu kopums tiek atjaunināts:
Dokumenti → Sadalīšana fragmentos → Iegultnes → Vektoru krātuve
Jautājums notiek tiešsaistē, uz katru uzdoto jautājumu, un tam jābūt ātram:
Jautājums → Iegultne → Meklēšana → Konteksts + Jautājums → LLM → Atbilde
Šim nodalījumam ir praktiskas sekas: ievades izmaksas tiek segtas vienreiz un var būt lielas, savukārt jautājumu izmaksas tiek segtas par katru izsaukumu un nosaka lietotāja pieredzi. Tāpēc vari atļauties sarežģītu ievades apstrādi, bet jautājumu pusē tev jāpaliek vieglam un ātram.
Pilnīga implementācija
Tālāk redzamā klase materializē trīs posmus trīs atsevišķās metodēs, plus ceturtā metode, kas tās visas sasaista kopā. Šis nodalījums nav tikai kosmētika: tas ļauj testēt meklēšanu, netērējot ģenerēšanas tokenus, un atkārtoti ģenerēt atbildi, balstoties uz fiksētu kontekstu, lai salīdzinātu divus komandējumus.
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
]
}
Trīs detaļas ģenerēšanas posmā nosaka lielāko daļu no kvalitātes. Sistēmas ziņojums pieprasa atbildēt tikai, balstoties uz sniegtajiem dokumentiem, un atzīt, kad informācijas trūkst: bez šīs instrukcijas modelis aizpildīs tukšumus ar savām vispārējām zināšanām, radot ticamu, bet izgudrotu atbildi. Prefikss [Source: id] pirms katra izraksta dod modelim kaut ko konkrētu, uz ko atsaukties, nevis miglainu „saskaņā ar dokumentiem”. Visbeidzot, temperature vērtība 0.2 samazina variabilitāti: faktisku jautājumu gadījumā, strādājot ar dokumentu bāzi, tev vajadzīga konsekvence, nevis radošums.
Lietošana
Pārbaudīsim darbplūsmu, izmantojot minimālu biznesa gadījumu — trīs iekšējās politikas un jautājumu, kas neatkārto nevienu no to precīzajiem formulējumiem.
# 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']}")
Virzi vingrinājumu tālāk, uzdodot jautājumu, uz kuru neviens dokuments neatbild, piemēram, jautājumu par uzņēmuma veselības apdrošināšanas plānu. Darbplūsma joprojām atgriezīs trīs avotus — meklēšana vienmēr atgriež savus k labākos kandidātus — un tieši sistēmas ziņojumam ir jānovērš modeļa mēģinājums izgudrot atbildi. Šīs uzvedības pārbaude pirms nodošanas ekspluatācijā ir labāka nekā tās atklāšana, saņemot sūdzību.
Optimizācijas punkti
Katru darbplūsmas soli var uzlabot neatkarīgi, ļaujot progresēt ar maziem, izmērāmiem pielāgojumiem.
| Solis | Iespējamās optimizācijas |
|---|---|
| Sadalīšana fragmentos | Fragmenta izmērs, pārklāšanās, semantiskā sadalīšana |
| Iegultne | Modeļa izvēle, dimensijas, teksta bagātināšana |
| Meklēšana | Hibrīda meklēšana, pārkārtošana (reranking), metadatu filtri |
| Komandējums | Sistēmas instrukcijas, konteksta formāts, few-shot piemēri |
| Ģenerēšana | Modelis, temperatūra, atsauces |
Turpmākajās nodarbībās tiks detalizēti aplūkota katra no šīm optimizācijām. Pievērsies tām šādā secībā: sadalīšana fragmentos nosaka to, ko var atrast, un neviena pārkārtošana neizlabos slikti sadalītu dokumentu.
Galvenās atziņas
- RAG = Meklēšana + Konteksts + LLM ģenerēšana
- Darbplūsma sadalās ievadē (bezsaiste) un jautājumā (tiešsaiste)
- Katru komponenti (sadalīšana, iegultne, meklēšana, komandējums, ģenerēšana) var optimizēt neatkarīgi
- RAG ir elastīgāks un lētāks nekā smalkā noregulēšana, pievienojot zināšanas