Kehotusten rikastaminen hakutoiminnoilla
Tällä sivulla
Oppitunti päivitetty 3. marraskuuta 2026 OpenAI:n dokumentaation perusteella: parametreja
temperaturejatop_phyväksytään vain, kun päättelyvaatimus onnone, kun taas GPT-5.6-mallit käyttävät oletusarvoisesti päättelyä (medium). Näitä parametreja asettavien kutsujen on siksi määritettäväreasoning={"effort": "none"}(Responses API) taireasoning_effort="none"(Chat Completions). Lähteet: Using GPT-6 · GPT-5.6 Terra.
Kehotusten rikastaminen hakutoiminnoilla
Kehotusten rikastaminen hakutoiminnoilla (Retrieval-Augmented Prompting, RAP) yhdistää dokumenttien haun kehotuksiin tarjotakseen mallille asiaankuuluvaa ja ajantasaista kontekstia. Se on luonteva jatke perustamiselle (grounding): manuaalisen kontekstin syöttämisen sijaan automatisoit relevanttien kohtien haun ennen jokaista LLM-kutsua.
Ero käy ilmeiseksi skaalautuessa. Kolmen hyödyllisen kappaleen liimaaminen dokumentaatiostasi toimii demossa, mutta kun dokumenttikantasi kasvaa satoihin sivuihin ja kysymyksiä saapuu jatkuvasti, kukaan ei enää tiedä, mitkä kohdat pitäisi liittää. RAP siirtää tämän valinnan automaattiselle komponentille, jota suoritetaan ennen jokaista generointia ja jonka ainoa tehtävä on löytää kehotukseen lisättävä sisältö.
RAP-järjestelmän arkkitehtuuri
RAP-putkisto jakautuu kolmeen vaiheeseen, jotka toimivat eri nopeuksilla ja kustannuksilla. Indeksointi muuntaa dokumenttisi vektoriembeddingeiksi; tämä tapahtuu kerran offline-tilassa muuntaen jokaisen dokumentin numeeriseksi vektoriksi, joka koodaa sen merkityksen, ja tallentaen sen alkuperäisen tekstin viereen. Haku sen sijaan suoritetaan jokaisen kysymyksen yhteydessä: muunnat kysymyksen vektoriksi käyttämällä samaa embedding-mallia ja etsit sitten lähimmät dokumenttivektorit. Lopuksi rikastaminen on vain tavallista kehotusten laatimista – rakennat järjestelmäkehotuksen, joka sisältää haetut kohdat, ja ohjeistat mallia olemaan ylittämättä tätä rajaa.
Muista tämä jako: kaikki kallista tapahtuu indeksoinnin aikana, jolloin voit olla vaativa, kun taas kaikki, mikä toistuu jokaisen kysymyksen kohdalla, on pidettävä nopeana. Alla oleva koodi toteuttaa kaksi ensimmäistä vaihetta käyttäen kosinussimilariteettia läheisyysmittarina.
from openai import OpenAI
import numpy as np
client = OpenAI()
# Step 1: Generate document embeddings
def embed_texts(texts: list[str]) -> list[list[float]]:
"""Generates embeddings for a list of texts."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=texts
)
return [item.embedding for item in response.data]
# Step 2: Search by cosine similarity
def cosine_similarity(a: list[float], b: list[float]) -> float:
"""Calculates cosine similarity between two vectors."""
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]:
"""Returns the top_k most relevant documents."""
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]]
Täydellinen putkisto
Näiden rakennuspalikoiden yhdistäminen tuottaa luokan, joka mahtuu noin kolmeenkymmeneen riviin. Useimmat päätökset tehdään generoidussa järjestelmäkehotuksessa, ja se kannattaa lukea rivi riviltä. Malli saa ensin käskyn vastata VAIN annettujen kohtien perusteella, mikä rajoittaa hallusinaatioita, kun dokumentaatio ei tarjoa vastausta. Se saa sitten ohjeen siteerata kohdan numero jokaisen väittämän yhteydessä, ja tämä mahdollistaa varmentamisen: tarkastaja voi jäljittää lähteen silmänräpäyksessä. temperature-arvo 0,1 viimeistelee asetelman: dokumentteihin ankkuroituneessa vastauksessa luovuus on virhe.
class RAGPipeline:
"""Minimalistinen RAP-putkisto."""
def __init__(self, documents: list[str]):
self.documents = documents
self.embeddings = embed_texts(documents)
def query(self, question: str, top_k: int = 3) -> str:
"""Vastaa kysymykseen dokumenttien perusteella."""
# Haku
relevant_docs = retrieve(
question, self.documents,
self.embeddings, top_k
)
# Kehotuksen rikastaminen
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}"""
# Generointi
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
Paloitteleminen: dokumenttien jakaminen
Dokumenttien jakaminen osiin (chunking) on ratkaisevan tärkeää haun laadulle. Jos osat ovat liian suuria, ne hukuttavat alleen relevantin informaation; jos liian pieniä, ne menettävät kontekstin. Kymmenen sivun lohkoihin jaettu API-käsikirja palauttaa aina saman yleisen lohkon kysymyksestä riippumatta. Yksittäisiin lauseisiin jaettuna se palauttaa lauseen, joka alkaa sanoilla “tämä metodi”, ilman että malli tietää, mistä metodista on kyse. Päällekkäisyys nimenomaan lieventää tätä riskiä: jokainen osa toistaa edellisen lopun, joten rajan yli ulottuva informaatio pysyy luettavana ainakin toiselta puolelta.
Kun dokumenteissasi on otsikkorakenne, osioihin perustuva paloitteleminen on lähes aina parempi kuin kiinteän kokoisen paloittelemisen: “Todennus”-osio pysyy ehjänä johdantoineen ja esimerkkeineen.
def chunk_document(text: str, chunk_size: int = 500,
overlap: int = 50) -> list[str]:
"""Splits text into chunks with overlap."""
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]:
"""Splits by sections (Markdown headings)."""
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
Edistyneet hakustrategiat
Uudelleenjärjestely (Reranking)
Alkuperäisen haun jälkeen käytä LLM:ää tulosten uudelleenjärjestelyyn. Logiikka on kuin suppilossa: vektorihaku on nopeaa mutta likimääräistä, tuoden esiin tusinan uskottavaa ehdokasta; malli, hitaampi mutta hienovaraisempi, lukee nämä ehdokkaat uudelleen kysymyksen valossa ja järjestää ne. Säilytät generointia varten vain listan kärjen. Hyöty on näkyvin kysymyksissä, joissa useat kohdat käsittelevät samaa aihetta, mutta vain yksi itse asiassa vastaa kysymykseen – kolme osiota mainitsee sanan “kiintiö”, mutta vain yksi selittää, miten sitä nostetaan.
def rerank(question: str, passages: list[str]) -> list[str]:
"""Reorders passages by relevance using the 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
)
# Parse returned order and reorganize
return response.output_text
Hypoteettinen dokumenttiembedding (HyDE)
Generoi ihanteellinen hypoteettinen dokumentti ja etsi sitten samankaltaisia dokumentteja. Ongelma, jonka tämä tekniikka ratkaisee, on sanaston epäsuhta: arkikielellä esitetty kysymys ei vektoritasolla näytä samalta kuin teknisen dokumentaation kappale. Pyytämällä mallia ensin kirjoittamaan kuviteltu vastaus saat tekstin, joka on kirjoitettu dokumenttiesi rekisterillä, ja juuri tätä tekstiä käytät hakukyselynä. Sillä ei ole väliä, sisältääkö hypoteettinen kappale epätarkkuuksia: sitä ei koskaan käytetä vastauksena, vaan ainoastaan koettimena.
def hyde_retrieve(question: str, documents: list[str],
doc_embeddings: list[list[float]]) -> list[str]:
"""Retrieval via HyDE."""
# Generate a hypothetical passage
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
# Search for documents similar to the hypothetical passage
return retrieve(hypothetical_doc, documents,
doc_embeddings, top_k=3)
OpenAI:n natiivin File Searchin käyttäminen
Nopeaa käyttöönottoa varten API tarjoaa integroidun haun. Lataat tiedoston, luot vektorivaraston, liität tiedoston siihen ja määrität file_search-työkalun kutsussa: paloitteleminen, embedding ja haku hoidetaan palvelinpuolella. Tämä on oikea valinta, kun dokumenttisi ovat standardimuotoisia etkä välitä siitä, missä data sijaitsee. Itse rakennettu putkisto säilyttää etunsa heti, kun tarvitset hallintaa paloittelemiseen, isännöit indeksiä itse tai haluat liittää mukaan erityistä uudelleenjärjestelyä.
# Upload file
file = client.files.create(
file=open("documentation.pdf", "rb"),
purpose="assistants"
)
# Create a vector store
vector_store = client.vector_stores.create(
name="Technical Documentation"
)
client.vector_stores.files.create(
vector_store_id=vector_store.id,
file_id=file.id
)
# Query with File Search
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]
}]
)
Luo perustaso
Ota viidestä kymmeneen sivua teknistä dokumentaatiota ja toteuta koko putkisto paloittelemisesta generointiin. Kirjoita kymmenen kysymystä, joiden vastaukset löytyvät dokumenteista, suorita putkisto kullekin ja toista sitten uudelleenjärjestely käytössä: havainnoimalla, missä kysymyksissä järjestys muuttuu, ymmärrät, mitä pelkkä vektorihaku ei tavoita. Lopeta mittaamalla oikein ankkuroitujen vastausten prosenttiosuus, eli niiden, joissa jokainen väittämä viittaa tehokkaasti annettuun kohtaan. Tämä luku on lähtökohtasi; kaikkia myöhempiä optimointeja arvioidaan tätä vasten, ei kahden tai kolmen satunnaisesti luetun vastauksen jättämän vaikutelman perusteella.
Keskeiset asiat
- RAP automatisoi relevantin kontekstin syöttämisen kehotukseen
- Paloitteleminen on kriittistä: kokeile eri kokoja
- Uudelleenjärjestely LLM:llä parantaa merkittävästi relevanssia
- HyDE on hyödyllinen, kun kysymys poikkeaa suuresti dokumenttien sanastosta
- OpenAI File Search yksinkertaistaa käyttöönottoa standarditapauksissa