Promptování s rozšířeným vyhledáváním
Na této stránce
Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry
temperatureatop_pjsou přijímány pouze při úsilí o uvažování (reasoning effort) nastaveném nanone, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která nastavují tyto parametry, musí proto specifikovatreasoning={"effort": "none"}(Responses API) neboreasoning_effort="none"(Chat Completions). Zdroje: Používání GPT-6 · GPT-5.6 Terra.
Promptování s rozšířeným vyhledáváním
Promptování s rozšířeným vyhledáváním (Retrieval-Augmented Prompting, RAP) kombinuje vyhledávání v dokumentech s tvorbou promptů, aby se modelu poskytl relevantní a aktuální kontext. Jde o přirozený vývoj uzemňování (grounding): místo ručního vkládání kontextu automatizujete vyhledávání relevantních pasáží před každým voláním LLM.
Rozdíl je zřejmý při větším měřítku. Ruční kopírování tří užitečných odstavců z vaší dokumentace funguje pro demo; jakmile však vaše dokumentace naroste na několik set stran a otázky přicházejí nepřetržitě, nikdo už neví, které pasáže vložit. RAP deleguje tuto volbu na automatickou komponentu, která se spustí před každou generací a jejímž jediným úkolem je najít to, co patří do promptu.
Architektura systému RAP
Pipeline RAP se skládá ze tří kroků, které fungují různou rychlostí a s různými náklady. Indexování transformuje vaše dokumenty do vektorových embeddingů; to se děje jednou, offline, přičemž každý dokument se změní na číselný vektor zakódující jeho význam a uloží se spolu s původním textem. Naproti tomu vyhledávání (Retrieval) běží u každé otázky: otázku převedete na vektor pomocí stejného embedding modelu a poté vyhledáte nejbližší vektory dokumentů. Nakonec je rozšíření (Augmentation) jen standardní promptování – vytvoříte systémový prompt obsahující načtené pasáže a instrukci modelu, aby se mimo tento rozsah nepouštěl.
Zapamatujte si toto rozdělení: vše nákladné se děje během indexování, kde si můžete dovolit být nároční, zatímco vše, co se opakuje pro každou otázku, musí zůstat rychlé. Níže uvedený kód implementuje první dva kroky s použitím kosinové podobnosti jako míry blízkosti.
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]]
Kompletní pipeline
Sestavením těchto stavebních kamenů vznikne třída, která se vejde asi do třiceti řádků. Většina rozhodnutí probíhá v generovaném systémovém promptu a stojí za to si ho přečíst řádek po řádku. Model nejprve obdrží příkaz odpovídat POUZE na základě poskytnutých pasáží, což omezuje halucinované odpovědi, když je dokumentace němá. Následuje instrukce citovat číslo pasáže pro každé tvrzení, což umožňuje ověření: recenzent může na první pohled vysledovat zdroj zpět. Hodnota temperature 0,1 setup dokončuje – u odpovědi zakotvené v dokumentech je kreativita chybou.
class RAGPipeline:
"""Minimalistický pipeline RAP."""
def __init__(self, documents: list[str]):
self.documents = documents
self.embeddings = embed_texts(documents)
def query(self, question: str, top_k: int = 3) -> str:
"""Odpovídá na otázku na základě dokumentů."""
# Vyhledávání
relevant_docs = retrieve(
question, self.documents,
self.embeddings, top_k
)
# Rozšíření promptu
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}"""
# Generování
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
Chunking: Rozdělování dokumentů
Rozdělování dokumentů na chunky (úseky) je zásadní pro kvalitu vyhledávání. Pokud jsou chunky příliš velké, utopí relevantní informace; pokud jsou příliš malé, ztratí kontext. Manuál k API rozdělený na desetistránkové bloky vždy vrátí stejný obecný blok bez ohledu na položenou otázku. Rozděleno na izolované věty vrátí větu začínající „tato metoda“, aniž by model věděl, o kterou metodu jde. Překryv (overlap) toto riziko specificky mitiguje: každý chunk opakuje konec toho předchozího, takže informace přesahující hranici zůstává čitelná alespoň z jedné strany.
Pokud mají vaše dokumenty strukturu nadpisů, je chunkování podle sekcí téměř vždy lepší než chunkování s pevnou velikostí: sekce „Autentizace“ zůstane nedotčená i s úvodem a příklady.
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
Pokročilé strategie vyhledávání
Přehodnocení (Reranking)
Po počátečním vyhledání použijte LLM k přeřazení výsledků. Logika je zde jako u trychtýře: vektorové vyhledávání je rychlé, ale přibližné, a přinese tucet pravděpodobných kandidátů; model, pomalejší, ale nuancovanější, si tyto kandidáty znovu přečte se znalostí otázky a seřadí je. Pro generaci pak ponecháte pouze špičku seznamu. Zisk je nejviditelnější u otázek, kde několik pasáží mluví o stejném tématu, ale pouze jedna na něj skutečně odpovídá – tři sekce zmiňují slovo „kvóta“, ale pouze jedna vysvětluje, jak ji zvýšit.
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
Hypotetické vnoření dokumentu (HyDE)
Vygenerujte ideální hypotetický dokument a poté vyhledejte podobné dokumenty. Problém, který tato technika řeší, je neshoda slovní zásoby: otázka položená hovorovým jazykem nevypadá z vektorového hlediska jako odstavec technické dokumentace. Tím, že nejprve požádáte model, aby napsal odpověď, jakou si představuje, získáte text psaný registrem vašich dokumentů, a právě tento text použijete jako dotaz. Nezáleží na tom, pokud hypotetický odstavec obsahuje nepřesnosti: nikdy neslouží jako odpověď, pouze jako sonda.
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)
Použití nativního File Search od OpenAI
Pro rychlé nasazení nabízí API integrované vyhledávání. Nahrajete soubor, vytvoříte úložiště vektorů (vector store), připojíte k němu soubor a ve volání deklarujete nástroj file_search: chunkování, embedding i vyhledávání jsou zpracovány na straně serveru. To je správná volba, když jsou vaše dokumenty standardní a nezajímá vás, kde data fyzicky leží. Vlastní pipeline si udržuje výhodu, jakmile potřebujete mít pod kontrolou chunkování, hostovat index sami nebo zapojit specifické přehodnocování (reranking).
# 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]
}]
)
Stanovení výchozího bodu (Baseline)
Vezmi pět až deset stran technické dokumentace a implementuj kompletní pipeline od chunkování až po generování. Napiš deset otázek, jejichž odpovědi jsou v dokumentech obsaženy, spusť na každou pipeline a poté opakuj s povoleným přehodnocením (reranking): právě pozorováním, u kterých otázek se pořadí změní, pochopíš, co samotné vektorové vyhledávání postrádá. Nakonec změř procento správně zakotvených odpovědí, tedy těch, kde se každé tvrzení efektivně odkazuje na poskytnutou pasáž. Toto číslo je tvým startovním bodem; všechny následné optimalizace budou posuzovány vůči němu, nikoli vůči dojmu ze dvou či tří náhodně přečtených odpovědí.
Klíčové poznatky
- RAP automatizuje vkládání relevantního kontextu do promptu
- Chunking je kritický: experimentuj s různými velikostmi
- Přehodnocení (Reranking) pomocí LLM významně zlepšuje relevanci
- HyDE je užitečné, když se otázka velmi liší slovní zásobou od dokumentů
- OpenAI File Search zjednodušuje nasazení pro standardní případy