Užklausomis pagrįstas raginimas su gavimu
Šiame puslapyje
Pamoka atnaujinta 2026 m. lapkričio 3 d. pagal „OpenAI“ dokumentaciją: parametrai
temperatureirtop_ppriimami tik esantnonelygio samprotavimui, tuo tarpu GPT-5.6 modeliai pagal nutylėjimą samprotauja (medium). Todėl kvietimuose, kuriuose nustatomi šie parametrai, būtina nurodytireasoning={"effort": "none"}(Responses API) arbareasoning_effort="none"(Chat Completions). Šaltiniai: Using GPT-6 · GPT-5.6 Terra.
Užklausomis pagrįstas raginimas su gavimu
Užklausomis pagrįstas raginimas su gavimu (angl. Retrieval-Augmented Prompting, RAP) sujungia dokumentų paiešką su raginimu, kad modelis gautų aktualų ir naujausią kontekstą. Tai natūralus įtvirtinimo evoliucijos etapas: vietoj rankinio konteksto įterpimo, prieš kiekvieną didžiojo kalbos modelio (LLM) kvietimą automatizuojate tinkamų ištraukų paiešką.
Skirtumas tampa akivaizdus dideliu mastu. Rankinis trijų naudingų pastraipų iš jūsų dokumentacijos įklijavimas tinka demonstracijai; tačiau kai dokumentacijos bazė išauga iki kelių šimtų puslapių, o klausimai plūsta nuolat, niekas nebežino, kurias pastraipas įklijuoti. RAP perduoda šį pasirinkimą automatiniam komponentui, kuris vykdomas prieš kiekvieną generavimą ir kurio vienintelis vaidmuo – surasti, ką įdėti į raginimą.
RAP sistemos architektūra
RAP konvejerį sudaro trys veiksmai, vykstantys skirtingu greičiu ir kainuojantys skirtingai. Indeksavimas paverčia jūsų dokumentus vektorių įterpiniais; tai atliekama vieną kartą neprisijungus, kiekvieną dokumentą paverčiant skaitiniu vektoriumi, koduojančiu jo prasmę, ir saugant jį kartu su originaliu tekstu. Gavimas, priešingai, vyksta kiekvieno klausimo metu: klausimą paverčiate vektoriumi naudodami tą patį įterpimo modelį, tada ieškote artimiausių dokumentų vektorių. Galiausiai, papildymas yra tiesiog standartinis raginimas – sukuriate sistemos raginimą, kuriame yra gautos ištraukos, ir nurodote modeliui neišeiti už šių ribų.
Įsiminkite šį suskirstymą: viskas, kas brangu, vyksta indeksavimo metu, kai galite sau leisti būti reiklūs, o viskas, kas kartojasi kiekvienam klausimui, turi išlikti greita. Toliau pateiktas kodas įgyvendina pirmuosius du veiksmus, naudodamas kosinusinį panašumą kaip artumo matą.
from openai import OpenAI
import numpy as np
client = OpenAI()
# 1 žingsnis: generuoti dokumentų įterpinius
def embed_texts(texts: list[str]) -> list[list[float]]:
"""Generuoja įterpinius tekstų sąrašui."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=texts
)
return [item.embedding for item in response.data]
# 2 žingsnis: paieška pagal kosinusinį panašumą
def cosine_similarity(a: list[float], b: list[float]) -> float:
"""Apskaičiuoja kosinusinį panašumą tarp dviejų vektorių."""
a, b = np.array(a), np.array(b)
return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))
def retrieve(query: str, documents: list[str],
doc_embeddings: list[list[float]],
top_k: int = 3) -> list[str]:
"""Grąžina top_k aktualiausių dokumentų."""
query_emb = embed_texts([query])[0]
scores = [
(i, cosine_similarity(query_emb, doc_emb))
for i, doc_emb in enumerate(doc_embeddings)
]
scores.sort(key=lambda x: x[1], reverse=True)
return [documents[i] for i, _ in scores[:top_k]]
Pilnas konvejeris
Sujungus šiuos statybinius blokus gaunama klasė, kuri telpa į apie trisdešimt eilučių. Dauguma sprendimų priimami sugeneruotame sistemos raginime, ir verta jį perskaityti eilutė po eilutės. Modelis pirmiausia gauna įsakymą atsakyti TIK remiantis pateiktomis ištraukomis, o tai sumažina haliucinacijas, kai dokumentacija tyli. Tada gaunamas nurodymas cituoti ištraukos numerį kiekvienam teiginiui, ir būtent tai leidžia patikrinti: recenzentas gali akimirksniu atsekti šaltinį. temperature reikšmė 0,1 užbaigia sąranką – atsakyme, pagrįstame dokumentais, kūrybiškumas yra klaida.
class RAGPipeline:
"""Minimalistinis RAP konvejeris."""
def __init__(self, documents: list[str]):
self.documents = documents
self.embeddings = embed_texts(documents)
def query(self, question: str, top_k: int = 3) -> str:
"""Atsako į klausimą remdamasis dokumentais."""
# Gavimas
relevant_docs = retrieve(
question, self.documents,
self.embeddings, top_k
)
# Raginimo papildymas
context = "\n\n---\n\n".join(
f"[Passage {i+1}]\n{doc}"
for i, doc in enumerate(relevant_docs)
)
system = f"""You are a technical assistant.
Answer ONLY based on the provided passages.
If the passages do not contain the answer, say so.
Cite the passage number for every claim.
RELEVANT PASSAGES:
{context}"""
# Generavimas
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
instructions=system,
input=question,
temperature=0.1
)
return response.output_text
Skaidymas: dokumentų dalijimas
Dokumentų skaidymas į dalis yra kritiškai svarbus gavimo kokybei. Jei dalys per didelės, jos nustelbia aktualią informaciją; jei per mažos – prarandamas kontekstas. API vadovas, padalintas į dešimties puslapių blokus, visada grąžins tą patį bendrą bloką, nepaisant užduoto klausimo. Padalijus į atskirus sakinius, bus grąžintas sakinys, prasidedantis „šis metodas“, o modelis nežinos, apie kurį metodą kalbama. Persidengimas būtent ir mažina šią riziką: kiekviena dalis pakartoja ankstesnės dalies pabaigą, todėl informacija, kertanti ribą, lieka skaitoma bent iš vienos pusės.
Kai jūsų dokumentai turi antraščių struktūrą, skaidymas pagal skyrius beveik visada yra pranašesnis už skaidymą fiksuoto dydžio dalimis: „Autentifikavimo“ skyrius lieka vientisas kartu su įvadu ir pavyzdžiais.
def chunk_document(text: str, chunk_size: int = 500,
overlap: int = 50) -> list[str]:
"""Skaido tekstą į dalis su persidengimu."""
words = text.split()
chunks = []
for i in range(0, len(words), chunk_size - overlap):
chunk = " ".join(words[i:i + chunk_size])
if chunk.strip():
chunks.append(chunk)
return chunks
def chunk_by_sections(text: str) -> list[str]:
"""Skaido pagal skyrius („Markdown“ antraštes)."""
sections = []
current = []
for line in text.split("\n"):
if line.startswith("## ") and current:
sections.append("\n".join(current))
current = [line]
else:
current.append(line)
if current:
sections.append("\n".join(current))
return sections
Pažangios gavimo strategijos
Perrikiavimas
Po pradinio gavimo naudokite LLM rezultatams perrikiuoti. Logika yra piltuvo principas: vektorių paieška yra greita, bet apytikslė, ji grąžina apie дюжинą tikėtinų kandidatų; modelis, lėtesnis, bet niuansuotesnis, perskaito šiuos kandidatus žinodamas klausimą ir juos surikiuoja. Tada generavimui paliekate tik sąrašo viršūnę. Naudą labiausiai pajusite ten, kur kelios ištraukos kalba apie tą pačią temą, bet tik viena iš tikrųjų atsako į klausimą – trys skyriai mini žodį „kvota“, bet tik vienas paaiškina, kaip ją padidinti.
def rerank(question: str, passages: list[str]) -> list[str]:
"""Perrikiuoja ištraukas pagal aktualumą naudojant LLM."""
prompt = f"""Question: {question}
Here are candidate passages. Rank them from most relevant
to least relevant for answering the question.
Return only the numbers in order (e.g., 3, 1, 2).
{chr(10).join(f"[{i+1}] {p[:200]}" for i, p in enumerate(passages))}"""
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0
)
# Išanalizuokite grąžintą tvarką ir pertvarkykite
return response.output_text
Hipotetinis dokumento įterpinys (HyDE)
Sugeneruokite idealų hipotetinį dokumentą, tada ieškokite panašių dokumentų. Problema, kurią ši technika sprendžia, yra žodyno neatitikimas: kasdiene kalba užduotas klausimas vektorine prasme neatrodo kaip techninės dokumentacijos pastraipa. Pirmiausia paprašius modelio parašyti atsakymą, kurį jis įsivaizduoja, gaunate tekstą, parašytą jūsų dokumentų registru, ir būtent šį tekstą naudojate kaip užklausą. Nesvarbu, jei hipotetinėje pastraipoje yra netikslumų: ji niekada netarnauja kaip atsakymas, o tik kaip zondas.
def hyde_retrieve(question: str, documents: list[str],
doc_embeddings: list[list[float]]) -> list[str]:
"""Gavimas naudojant HyDE."""
# Generuoti hipotetinę ištrauką
hypo_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=f"Write a short technical paragraph that would perfectly "
f"answer this question: {question}",
temperature=0.5
)
hypothetical_doc = hypo_response.output_text
# Ieškoti dokumentų, panašių į hipotetinę ištrauką
return retrieve(hypothetical_doc, documents,
doc_embeddings, top_k=3)
„OpenAI“ vietinės failų paieškos naudojimas
Greitam diegimui API siūlo integruotą gavimą. Įkeliate failą, sukuriate vektorių saugyklą, priskiriate jai failą ir kvietime deklaruojate įrankį file_search: skaidymas, įterpimas ir paieška tvarkomi serverio pusėje. Tai tinkamas pasirinkimas, kai jūsų dokumentai yra standartiniai ir jums nerūpi, kur duomenys saugomi. Savas konvejeris išlaiko pranašumą tada, kai reikia valdyti skaidymą, patiems hostinti indeksą arba prijungti specifinį perrikiavimą.
# Įkelti failą
file = client.files.create(
file=open("documentation.pdf", "rb"),
purpose="assistants"
)
# Sukurti vektorių saugyklą
vector_store = client.vector_stores.create(
name="Technical Documentation"
)
client.vector_stores.files.create(
vector_store_id=vector_store.id,
file_id=file.id
)
# Užklausa naudojant failų paiešką
response = client.responses.create(
model="gpt-5.6-terra",
instructions="Answer based on the provided documentation.",
input="How do I configure authentication?",
tools=[{
"type": "file_search",
"vector_store_ids": [vector_store.id]
}]
)
Nustatykite bazinį lygį
Paimkite penkis–dešimt techninės dokumentacijos puslapių ir įgyvendinkite visą konvejerį nuo skaidymo iki generavimo. Parašykite dešimt klausimų, kurių atsakymai yra dokumentuose, paleiskite konvejerį kiekvienam iš jų, tada pakartokite įjungę perrikiavimą: stebėdami, kuriems klausimams keičiasi rikiavimas, suprasite, ko trūksta vien vektorių paieškai. Pabaigoje išmatuokite teisingai pagrįstų atsakymų procentinę dalį – tai tokie atsakymai, kuriuose kiekvienas teiginys efektyviai remiasi pateikta ištrauka. Šis skaičius yra jūsų starto taškas; visi vėlesni optimizavimai bus vertinami lyginant su juo, o ne su įspūdžiu, kurį palieka du ar trys atsitiktinai perskaityti atsakymai.
Svarbiausi punktai
- RAP automatizuoja aktualaus konteksto įterpimą į raginimą
- Skaidymas yra kritinis: eksperimentuokite su skirtingais dydžiais
- Perrikiavimas naudojant LLM žymiai pagerina aktualumą
- HyDE naudingas, kai klausimas labai skiriasi nuo dokumentų žodyno
- „OpenAI“ failų paieška supaprastina diegimą standartiniais atvejais