Išgavimas ir generavimas
Šiame puslapyje
Nuo vektoriaus iki atsakymo
Jau žinai, kaip indeksuoti dokumentus ir išgauti tuos, kurie labiausiai atitinka klausimą. Liko tik vienas žingsnis: paversti fragmentų sąrašą į skaitomą atsakymą. Tai reiškia įterpti gautą kontekstą į užklausą (prompt), kad didysis kalbos modelis (LLM) suformuluotų atsakymą remdamasis tavo duomenimis, o ne savo mokymo atmintimi. Tam užtenka kelių kodo eilučių, tačiau tai lemia esminį kokybės skirtumą. Tinkamai pateiktas kontekstas ir aiški instrukcija yra tokie pat svarbūs kaip ir išgavimo tikslumas.
RAG užklausos kūrimas
Užklausos struktūra paprasta, tačiau kiekvienas pasirinkimas turi pasekmių. Sunumeruok fragmentus ir pridėk jų šaltinį, kad modelis galėtų tiksliai cituoti. Atskirk juos matomu skirtuku ---, kad modelis nesulietų dviejų prieštaraujančių dokumentų į vieną teiginį. Svarbiausia – instrukcijoje turi būti aiškiai nurodyta, jog atsakymas turi remtis TIK pateiktu kontekstu, ir modelis turi turėti leidimą pasakyti, kad nežino atsakymo. Be tokio leidimo LLM, paklaustas apie trūkstamą informaciją, užpildys spragą tuo, kas atrodo tikėtina. Būtent taip ir atsiranda haliucinacijos.
def build_rag_prompt(question, retrieved_chunks):
"""Build the RAG prompt with retrieved context."""
# Format the context
context_parts = []
for i, chunk in enumerate(retrieved_chunks):
source = chunk.get("source", "unknown source")
context_parts.append(f"[Document {i+1} - {source}]\n{chunk['text']}")
context = "\n\n---\n\n".join(context_parts)
prompt = f"""You are an expert assistant. Answer the question using
ONLY the context provided below. If the information is not in the
context, say so clearly.
## Context
{context}
## Question
{question}
## Answer"""
return prompt
Atsakymo generavimas
Generavimo užklausa yra tiesmuka: sistemos žinutė, kuri pakartoja vaidmenį, ir naudotojo žinutė, kurioje pateikiama sukomplektuota užklausa. Atkreipk dėmesį į temperature parametrą, čia nustatytą į 0,1. Kūrybiniame rašyme norisi įvairovės, o RAG atveju – priešingai. Nori, kad modelis kuo labiau laikytųsi to, kas pasakyta kontekste, ir kad du vykdymai su tuo pačiu klausimu duotų tą patį atsakymą. Aukšta temperatūra paskatintų modelį perfrazuoti, ekstrapoliuoti ir nukrypti nuo šaltinio.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
"""Generate a RAG answer with Mistral."""
prompt = build_rag_prompt(question, retrieved_chunks)
response = client.chat.complete(
model=model,
messages=[
{
"role": "system",
"content": "You are a precise assistant that answers based on the provided context."
},
{
"role": "user",
"content": prompt,
}
],
temperature=0.1, # Low temperature for factual answers
)
return response.choices[0].message.content
# Example
question = "What are the main steps of RAG?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)
Veiksmo įkapsuliavimas klasėje
Išbarstytos funkcijos tinka tyrinėjimams, bet ne galutiniam pristatymui. Klasė RAGPipeline sujungia būseną – fragmentus, įterpčių (embeddings) matricą ir FAISS indeksą, sukurtą vieną kartą inicijavimo metu – bei tris operacijas: retrieve užkoduoja klausimą ir užklausia indeksą, generate surenka užklausą ir iškviečia modelį, o ask sujungia abu veiksmus. Atkreipk dėmesį, ką grąžina ask: ne eilutę, o žodyną, kuriame yra atsakymas, šaltinių sąrašas ir naudotų fragmentų skaičius. Šis atsekamumas ir skiria audituojamą asistentą nuo „juodosios dėžės“. Kai naudotojas suabejos atsakymu, tu žinosi, kuriais tekstais jis buvo pagrįstas.
import numpy as np
import faiss
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
class RAGPipeline:
"""Complete RAG pipeline with Mistral and FAISS."""
def __init__(self, chunks, embeddings):
self.chunks = chunks
self.embeddings = embeddings.astype(np.float32)
# Create the FAISS index
dimension = embeddings.shape[1]
self.index = faiss.IndexFlatL2(dimension)
self.index.add(self.embeddings)
def retrieve(self, question, k=3):
"""Step 1: retrieve relevant chunks."""
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):
"""Step 2: generate the answer with 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):
"""Full pipeline: question -> sourced answer."""
# Retrieval
context = self.retrieve(question, k=k)
# Generation
answer = self.generate(question, context)
return {
"question": question,
"answer": answer,
"sources": [c["source"] for c in context],
"n_chunks_used": len(context),
}
# Usage
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("How does indexing work in FAISS?")
print(f"Question: {result['question']}")
print(f"Answer: {result['answer']}")
print(f"Sources: {result['sources']}")
Trys užklausų variantai pagal naudojimo atvejį
Galite specializuoti bazinę užklausą priklausomai nuo to, ko tikitės iš asistento. Jei naudotojai privalo patikrinti kiekvieną teiginį, aiškiai paprašykite citatų laužtiniuose skliaustuose. Tuomet modelis kiekvieną sakinį susies su sunumeruotu dokumentu. Jei atsakymas skirtas sąsajai ar ataskaitai, struktūruotas formatas užtikrina stabilias sekcijas: glaustas atsakymas, detalės, šaltiniai ir pasitikėjimo lygis, atspindintis, kaip gerai kontekstas apima klausimą. Trečiasis variantas atlieka kitokį vaidmenį: jis moko modelį išskaidyti neapibrėžtumą, atskiriant tai, ką galima teigti užtikrintai, ko trūksta ir kur ieškoti toliau. Praktikoje tai dažnai sukurpa naudingiausius asistentus, nes „man trūksta X“ yra geriau nei pasitikintis, bet klaidingas atsakymas.
# 1. Prompt with citation instruction
prompt_cite = """Answer by citing source documents in brackets.
Example: "RAG improves accuracy [Document 1]."
Context: {context}
Question: {question}"""
# 2. Prompt with structured format
prompt_structured = """Answer in the following format:
**Answer**: [your concise answer]
**Details**: [detailed explanation]
**Sources**: [list of documents used]
**Confidence**: [high/medium/low based on context coverage]
Context: {context}
Question: {question}"""
# 3. Prompt with missing-information handling
prompt_honest = """If the context does not contain enough information to
answer completely, state clearly:
- What you can assert with certainty
- What is missing from the context
- Suggestions for obtaining the missing information
Context: {context}
Question: {question}"""
Kalbant apie iškvietimo parametrus, RAG elgseną valdo trys nustatymai. Žema temperatūra užfiksuoja faktinį išvesties turinį, max_tokens neleidžia atsakymams virsti esė, o konservatyvus top_p apriboja imties žodyną tik tikėtiniausiais tęsiniais.
# For RAG, use a low temperature
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # Factual, low creativity
max_tokens=1024, # Limit answer length
top_p=0.95, # Conservative nucleus sampling
)
Svarbiausi punktai
- RAG užklausa įterpia gautą kontekstą prieš klausimą
- Naudokite žemą temperatūrą (0,1–0,3) faktiniams atsakymams
- Paprašykite modelio cituoti šaltinius atsekamumui užtikrinti
- Klasė
RAGPipelineįkapsuliuoja visą eigą: išgavimas, generavimas, klausimas - Tvarkykite atvejus, kai kontekste trūksta pakankamai informacijos