Recuperare și Generare
Pe această pagină
De la Vector la Răspuns
Știți deja cum să indexați documente și să le recuperați pe cele mai apropiate de o întrebare. A mai rămas un singur pas: transformarea unei liste de fragmente într-un răspuns lizibil. Aceasta implică injectarea contextului recuperat într-un prompt, astfel încât LLM-ul să formuleze un răspuns bazat pe datele dumneavoastră, nu pe memorile sale de antrenament. Este nevoie de doar câteva linii de cod, dar fac o diferență decisivă în calitate. Un context bine prezentat și o instrucțiune clară contează la fel de mult precum precizia recuperării.
Construirea Prompt-ului RAG
Structura prompt-ului este simplă, dar fiecare alegere are consecințe. Numerotați fragmentele și adnotați-le cu sursa lor, astfel încât modelul să poată cita precis. Separați-le printr-un delimitator vizibil, ---, pentru ca modelul să nu contopească două documente contradictorii într-o singură afirmație. Cel mai important, instrucțiunea trebuie să restricționeze explicit răspunsul la contextul furnizat și să permită modelului să declare că nu știe. Fără această permisiune, un LLM întrebat despre informații lipsă va umple golul cu orice pare plauzibil. Acesta este chiar mecanismul halucinației.
def build_rag_prompt(question, retrieved_chunks):
"""Construiește prompt-ul RAG cu contextul recuperat."""
# Formatează contextul
context_parts = []
for i, chunk in enumerate(retrieved_chunks):
source = chunk.get("source", "sursă necunoscută")
context_parts.append(f"[Document {i+1} - {source}]\n{chunk['text']}")
context = "\n\n---\n\n".join(context_parts)
prompt = f"""Ești un asistent expert. Răspunde la întrebare folosind
NUMAI contextul furnizat mai jos. Dacă informația nu se află în
context, spune acest lucru clar.
## Context
{context}
## Întrebare
{question}
## Răspuns"""
return prompt
Generarea Răspunsului
Apelul de generare este simplu: un mesaj de sistem care reiterează rolul și un mesaj de utilizator care conține prompt-ul asamblat. Acordați atenție parametrului temperature, setat aici la 0.1. În scrierea creativă, doriți varietate; în RAG, doriți opusul. Doriți ca modelul să rămână cât mai aproape posibil de ceea ce spune contextul și doriți ca două execuții pe aceeași întrebare să producă același răspuns. O temperatură ridicată ar împinge modelul să reformuleze, să extrapoleze și să se îndepărteze de sursă.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
"""Generează un răspuns RAG cu Mistral."""
prompt = build_rag_prompt(question, retrieved_chunks)
response = client.chat.complete(
model=model,
messages=[
{
"role": "system",
"content": "Ești un asistent precis care răspunde pe baza contextului furnizat."
},
{
"role": "user",
"content": prompt,
}
],
temperature=0.1, # Temperatură scăzută pentru răspunsuri factuale
)
return response.choices[0].message.content
# Exemplu
question = "Care sunt pașii principali ai RAG?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)
Încapsularea Fluxului într-o Clasă
Funcțiile disparate funcționează pentru explorare, nu pentru livrare. Clasa RAGPipeline grupează starea — fragmentele, matricea de embedding-uri și indexul FAISS construit o singură dată la instanțiere — și trei operațiuni: retrieve codifică întrebarea și interoghează indexul, generate asamblează prompt-ul și apelează modelul, iar ask înlănțuie cele două. Observați ce returnează ask: nu un șir de caractere, ci un dicționar care conține răspunsul, lista surselor și numărul de fragmente utilizate. Această trasabilitate este ceea ce separă un asistent auditabil de o cutie neagră. În ziua în care un utilizator contestă un răspuns, veți ști pe ce pasaje s-a bazat.
import numpy as np
import faiss
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
class RAGPipeline:
"""Pipeline RAG complet cu Mistral și FAISS."""
def __init__(self, chunks, embeddings):
self.chunks = chunks
self.embeddings = embeddings.astype(np.float32)
# Creează indexul FAISS
dimension = embeddings.shape[1]
self.index = faiss.IndexFlatL2(dimension)
self.index.add(self.embeddings)
def retrieve(self, question, k=3):
"""Pasul 1: recuperează fragmentele relevante."""
response = client.embeddings.create(
model="mistral-embed",
inputs=[question],
)
query_vector = np.array(
[response.data[0].embedding], dtype=np.float32
)
distances, indices = self.index.search(query_vector, k)
results = []
for dist, idx in zip(distances[0], indices[0]):
if idx >= 0:
results.append({
"text": self.chunks[idx]["text"],
"source": self.chunks[idx].get("source", ""),
"distance": float(dist),
})
return results
def generate(self, question, context_chunks):
"""Pasul 2: generează răspunsul cu context."""
prompt = build_rag_prompt(question, context_chunks)
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1,
)
return response.choices[0].message.content
def ask(self, question, k=3):
"""Pipeline complet: întrebare -> răspuns sourstat."""
# Recuperare
context = self.retrieve(question, k=k)
# Generare
answer = self.generate(question, context)
return {
"question": question,
"answer": answer,
"sources": [c["source"] for c in context],
"n_chunks_used": len(context),
}
# Utilizare
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("Cum funcționează indexarea în FAISS?")
print(f"Întrebare: {result['question']}")
print(f"Răspuns: {result['answer']}")
print(f"Surse: {result['sources']}")
Trei Variante de Prompt în Funcție de Cazul de Utilizare
Puteți specializa prompt-ul de bază în funcție de ceea ce așteptați de la asistent. Dacă utilizatorii dumneavoastră trebuie să verifice fiecare afirmație, cereți explicit citări între paranteze. Modelul va atașa apoi fiecare propoziție unui document numerotat. Dacă răspunsul alimentează o interfață sau un raport, un format structurat impune secțiuni stabile: un răspuns concis, detalii, surse și un nivel de încredere care reflectă cât de bine acoperă contextul întrebarea. A treia variantă joacă un rol diferit: îl învață pe model să descompună incertitudinea, distingând ceea ce poate afirma, ceea ce lipsește și unde să caute în continuare. Aceasta produce adesea cei mai utili asistenți în practică, deoarece „Îmi lipsește X“ bate un răspuns sigur, dar greșit.
# 1. Prompt cu instrucțiune de citare
prompt_cite = """Răspunde citând documentele sursă între paranteze.
Exemplu: „RAG îmbunătățește acuratețea [Document 1].“
Context: {context}
Întrebare: {question}"""
# 2. Prompt cu format structurat
prompt_structured = """Răspunde în următorul format:
**Răspuns**: [răspunsul tău concis]
**Detalii**: [explicație detaliată]
**Surse**: [lista documentelor utilizate]
**Încredere**: [ridicat/mediu/scăzut bazat pe acoperirea contextului]
Context: {context}
Întrebare: {question}"""
# 3. Prompt cu gestionarea informațiilor lipsă
prompt_honest = """Dacă contextul nu conține suficiente informații pentru a
răspunde complet, afirmă clar:
- Ce poți afirma cu certitudine
- Ce lipsește din context
- Sugestii pentru obținerea informațiilor lipsă
Context: {context}
Întrebare: {question}"""
În ceea ce privește parametrii apelului, trei setări guvernează comportamentul RAG. O temperatură scăzută blochează rezultatul factual, max_tokens previne răspunsurile care devin eseuri, iar un top_p conservator restricționează vocabularul eșantionat la cele mai probabile continuări.
# Pentru RAG, folosește o temperatură scăzută
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # Factual, creativitate scăzută
max_tokens=1024, # Limitează lungimea răspunsului
top_p=0.95, # Eșantionare nucleu conservatoare
)
Puncte cheie
- Prompt-ul RAG injectează contextul recuperat înainte de întrebare
- Folosiți o temperatură scăzută (0.1–0.3) pentru răspunsuri factuale
- Cereți modelului să citeze sursele pentru trasabilitate
- Clasa RAGPipeline încapsulează fluxul complet: retrieve, generate, ask
- Gestionați cazurile în care contextul nu conține informații suficiente