Pridobivanje in generiranje
Na tej strani
Od vektorja do odgovora
Znaš indeksirati dokumente in poiskati tiste, ki so najbližje zastavljenemu vprašanju. Preostane še en korak: seznam razdrobljenih delov (chunks) pretvoriti v berljiv odgovor. To pomeni vstavljanje pridobljenega konteksta v poziv (prompt), da veliki jezikovni model (LLM) oblikuje odgovor na podlagi tvojih podatkov in ne svojih spominov iz usposabljanja. Za to potrebuješ le nekaj vrstic kode, a to drastično izboljša kakovost. Dobro predstavljen kontekst in jasna navodila so prav tako pomembni kot natančnost pridobivanja.
Izgradnja poziva za RAG
Struktura poziva je preprosta, a ima vsaka izbira svoje posledice. Oštevilči dele in jih opatri z virom, da jih model lahko natančno citira. Loči jih z vidnim ločilom, ---, da model ne združi dveh nasprotujočih si dokumentov v eno samo trditev. Najpomembneje: navodilo mora izrecno omejiti odgovor na podani kontekst in modelu dovoliti, da reče, da ne ve. Brez tega dovoljenja bo LLM, ko ga vprašaš za manjkajoče informacije, vrzel zapolnil s čimerkoli, kar se zdi verjetno. To je prav mehanizem halucinacij.
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
Generiranje odgovora
Klic za generiranje je preprost: sistemsko sporočilo, ki ponovno določi vlogo, in uporabniško sporočilo, ki nosi sestavljeni poziv. Bod pozoren na parameter temperature, ki je tukaj nastavljen na 0,1. Pri ustvarjalnem pisanju želiš raznolikost; pri RAG-u želiš ravno nasprotno. Želiš, da se model čim bolj drži tega, kar piše v kontekstu, in želiš, da dva zagona z istim vprašanjem proizvedeta enak odgovor. Visoka temperatura bi model prisilila k preoblikovanju, ekstrapolaciji in oddaljevanju od vira.
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)
Zapiranje toka v razred
Razpršene funkcije delujejo za raziskovanje, ne pa za končno izvedbo. Razred RAGPipeline združuje stanje – dele, matriko vgradenj (embeddings) in indeks FAISS, zgrajen ob inicializaciji – ter tri operacije: retrieve kodira vprašanje in poizveduje po indeksu, generate sestavi poziv in pokliče model, ask pa ju poveže. Opazi, kaj vrača ask: ne niza, temveč slovar, ki vsebuje odgovor, seznam virov in število uporabljenih delov. Ta sledljivost loči revidirljivega pomočnika od črne škatle. Ko bo uporabnik nekoč izpodbijal odgovor, boš vedel, na katere odlomke se je opiral.
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']}")
Tri različice poziva glede na primer uporabe
Osnovni poziv lahko specializiraš glede na to, kaj pričakuješ od pomočnika. Če morajo tvoji uporabniki preveriti vsako trditev, izrecno zahtevaj citate v oglatih oklepajih. Model nato vsak stavek poveže z oštevilčenim dokumentom. Če odgovor napaja vmesnik ali poročilo, strukturirana oblika zagotavlja stabilne razdelke: jedrnat odgovor, podrobnosti, vire in raven zaupanja, ki odraža, kako dobro kontekst pokriva vprašanje. Tretja različica igra drugačno vlogo: model uči razčlenjevati negotovost z razlikovanjem med tem, kar lahko trdi, česa manjka in kam gledati naprej. To v praksi pogosto ustvari najbolj uporabne pomočnike, saj je „manjka mi X” bolje od samozavestnega, a napačnega odgovora.
# 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}"""
Kar zadeva parametre klica, tri nastavitve urejajo obnašanje RAG-a. Nizka temperatura zaklene dejanski izpis, max_tokens prepreči, da bi se odgovori razvlekli v eseje, konservativen top_p pa omeji vzorčni besednjak na najbolj verjetne nadaljevanja.
# 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
)
Ključne ugotovitve
- Poziv RAG vstavi pridobljeni kontekst pred vprašanje
- Za dejanske odgovore uporabi nizko temperaturo (0,1–0,3)
- Model prosi za navajanje virov zaradi sledljivosti
- Razred RAGPipeline zapira celoten tok: pridobi, generiraj, vprašaj
- Obravnavaj primere, ko kontekst nima dovolj informacij