Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Lekérdezés-bővített promptolás

9. lecke 16 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Lekérdezés-bővített promptolás
  2. Egy RAP-rendszer architektúrája
  3. Teljes folyamat
  4. Darabolás: dokumentumok felosztása
  5. Haladó lekérdezési stratégiák
  6. Az OpenAI natív File Search funkciójának használata
  7. Alapvonal meghatározása
  8. Főbb megállapítások

Lecke frissítve: 2026. november 3. az OpenAI dokumentációja alapján: a temperature és a top_p paraméterek csak none gondolkodási erőfeszítés mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) gondolkodnak. Ezért az ezeket a paramétereket beállító hívásoknak meg kell adniuk a reasoning={"effort": "none"} (Responses API) vagy reasoning_effort="none" (Chat Completions) értéket. Források: GPT-6 használata · GPT-5.6 Terra.

Lekérdezés-bővített promptolás

A lekérdezés-bővített promptolás (Retrieval-Augmented Prompting, RAP) egyesíti a dokumentumkeresést a promptolással, hogy releváns, naprakész kontextust biztosítson a modell számára. Ez a horgonyozás természetes evolúciója: a kontextus manuális beszúrása helyett automatizálod a releváns szakaszok keresését minden LLM-hívás előtt.

A különbség nagy léptékben válik nyilvánvalóvá. Három hasznos bekezdés manuális bemásolása a dokumentációból működik egy demónál; de ha a dokumentációs bázis eléri a néhány száz oldalt, és folyamatosan érkeznek a kérdések, senki sem tudja már, mely szakaszokat másolja be. A RAP ezt a döntést egy automatikus komponensre bízza, amely minden generálás előtt fut, és egyetlen feladata megtalálni, mi kerüljön a promptba.

Egy RAP-rendszer architektúrája

A RAP-folyamat három lépésre bontható, amelyek eltérő sebességgel és költséggel működnek. Az indexelés vektoros beágyazásokká (embeddings) alakítja át a dokumentumaidat; ez egyszer történik meg, offline módon, minden dokumentumot egy numerikus vektortá alakítva, amely kódolja a jelentését, és az eredeti szöveg mellett tárolja el. Ezzel szemben a lekérdezés minden kérdésre lefut: a kérdést ugyanazzal a beágyazási modellel vektortá alakítod, majd megkeresed a legközelebbi dokumentumvektorokat. Végül a bővítés nem más, mint szabványos promptolás: összeállítasz egy rendszerpromptot a lekért szakaszokkal, és utasítod a modellt, hogy ne lépjen ki ebből a keretből.

Jegyezd meg ezt a felosztást: minden, ami drága, az indexelés során történik, ahol megengedheted magadnak, hogy igényes legyél, míg mindennek, ami minden kérdésre megismétlődik, gyorsnak kell maradnia. Az alábbi kód az első két lépést valósítja meg, koszinusz-hasonlóságot használva közelségi mérőszámként.

from openai import OpenAI
import numpy as np

client = OpenAI()

# 1. lépés: Dokumentum-beágyazások generálása
def embed_texts(texts: list[str]) -> list[list[float]]:
    """Beágyazásokat generál szövegek listájához."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=texts
    )
    return [item.embedding for item in response.data]

# 2. lépés: Keresés koszinusz-hasonlóság alapján
def cosine_similarity(a: list[float], b: list[float]) -> float:
    """Kiszámítja két vektor koszinusz-hasonlóságát."""
    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]:
    """Visszaadja a top_k legrelevánsabb dokumentumot."""
    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]]

Teljes folyamat

Ezeknek az építőköveknek az összeillesztése egy körülbelül harminc soros osztályt eredményez. A döntések többsége a generált rendszerpromptban történik, és érdemes soronként átolvasni. A modell először azt a parancsot kapja, hogy KIZÁRÓLAG a megadott szakaszok alapján válaszoljon, ami korlátozza a hallucinált válaszokat, amikor a dokumentáció hallgat. Ezután utasítást kap, hogy minden állításnál hivatkozzon a szakasz számára, és ez teszi lehetővé az ellenőrzést: egy recenzens pillantással visszavezetheti az állítást a forráshoz. A beállítást egy 0,1-es temperature érték zárja le – dokumentumokra alapozott válasznál a kreativitás hiba.

class RAGPipeline:
    """Minimalista RAP folyamat."""

    def __init__(self, documents: list[str]):
        self.documents = documents
        self.embeddings = embed_texts(documents)

    def query(self, question: str, top_k: int = 3) -> str:
        """Válaszol egy kérdésre a dokumentumok alapján."""
        # Lekérdezés
        relevant_docs = retrieve(
            question, self.documents,
            self.embeddings, top_k
        )

        # Prompt bővítése
        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}"""

        # Generálás
        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

Darabolás: dokumentumok felosztása

A dokumentumok darabokra (chunkokra) osztása döntő fontosságú a lekérdezés minősége szempontjából. Ha a darabok túl nagyok, elnyomják a releváns információkat; ha túl kicsik, elveszik a kontextus. Egy tízoldalas blokkokra osztott API-kézikönyv mindig ugyanazt az általános blokkot adja vissza, függetlenül a feltett kérdéstől. Ha elszigetelt mondatokra osztod, olyan mondatot ad vissza, amely ezzel kezdődik: „ez a módszer“, anélkül, hogy a modell tudná, melyik módszerről van szó. Az átfedés kifejezetten ezt a kockázatot enyhíti: minden darab megismétli az előző végét, így a határon átnyúló információ legalább az egyik oldalról olvasható marad.

Ha a dokumentumaid rendelkeznek címszerkezettel, a szakaszalapú darabolás szinte mindig jobb, mint a fix méretű darabolás: egy „Hitelesítés“ szakasz egyben marad, a bevezetőjével és példáival együtt.

def chunk_document(text: str, chunk_size: int = 500,
                   overlap: int = 50) -> list[str]:
    """Szöveg felosztása átfedő darabokra."""
    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]:
    """Felosztás szakaszok szerint (Markdown címsorok)."""
    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

Haladó lekérdezési stratégiák

Újrarendezés (Reranking)

A kezdeti lekérdezés után használd az LLM-et az eredmények sorrendjének módosítására. A logika egy tölcséréhez hasonlít: a vektoros keresés gyors, de közelítő, és visszahoz egy tucatnyi lehetséges jelöltet; a modell, amely lassabb, de árnyaltabb, újraolvassa ezeket a jelölteket a kérdés ismeretében, és rangsorolja őket. Ezután csak a lista elejét tartod meg a generáláshoz. A nyereség leginkább azoknál a kérdéseknél látható, ahol több szakasz is ugyanarról a témáról szól, de csak egy válaszolja meg ténylegesen a kérdést – három szakasz említi a „kvóta“ szót, de csak egy magyarázza el, hogyan növelhető.

def rerank(question: str, passages: list[str]) -> list[str]:
    """Szakaszok újrarendezése relevancia szerint az LLM segítségével."""
    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
    )
    # A visszaadott sorrend parszolása és újrarendezés
    return response.output_text

Hipotetikus Dokumentum Beágyazás (HyDE)

Generálj egy ideális, hipotetikus dokumentumot, majd keress hasonló dokumentumokat. Ez a technika azt a problémát oldja meg, hogy a szókincs nem egyezik: a mindennapi nyelven feltett kérdés vektorosan nem néz ki úgy, mint egy technikai dokumentáció bekezdése. Ha először megkérdezed a modelltől, hogy írja meg az általa elképzelt választ, egy olyan szöveget kapsz, amely a dokumentumaid stílusregiszterében íródott, és ezt a szöveget használod lekérdezésként. Nem számít, ha a hipotetikus bekezdés közelítéseket tartalmaz: sosem szolgál válaszként, csak szondaként.

def hyde_retrieve(question: str, documents: list[str],
                  doc_embeddings: list[list[float]]) -> list[str]:
    """Lekérdezés HyDE segítségével."""
    # Hipotetikus szakasz generálása
    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

    # Dokumentumok keresése a hipotetikus szakaszhoz hasonlók között
    return retrieve(hypothetical_doc, documents,
                    doc_embeddings, top_k=3)

Az OpenAI natív File Search funkciójának használata

A gyors telepítés érdekében az API integrált lekérdezést kínál. Feltöltöd a fájlt, létrehozol egy vektortárat, csatolod hozzá a fájlt, és deklarálod a file_search eszközt a hívásban: a darabolást, a beágyazást és a keresést a szerver oldalán kezelik. Ez a helyes választás, ha a dokumentumaid szabványosak, és nem érdekel, hol élnek az adatok. A saját fejlesztésű folyamat akkor marad előnyben, ha uralnod kell a darabolást, saját magadnak kell hosztolnod az indexet, vagy specifikus újrarendezést kell csatlakoztatnod.

# Fájl feltöltése
file = client.files.create(
    file=open("documentation.pdf", "rb"),
    purpose="assistants"
)

# Vektortár létrehozása
vector_store = client.vector_stores.create(
    name="Technical Documentation"
)

client.vector_stores.files.create(
    vector_store_id=vector_store.id,
    file_id=file.id
)

# Lekérdezés File Search segítségével
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]
    }]
)

Alapvonal meghatározása

Vegyél öt-tíz oldal technikai dokumentációt, és valósítsd meg a teljes folyamatot a darabolástól a generálásig. Írj tíz kérdést, amelyekre a válaszok benne vannak a dokumentumokban, futtasd le a folyamatot mindegyiken, majd ismételd meg az újrarendezés engedélyezésével: annak megfigyelésével, hogy mely kérdéseknél változik a rangsor, értheted meg, mit mulaszt el a pusztán vektoros keresés. Végezd azzal, hogy megméred a helyesen horgonyzott válaszok százalékos arányát, azokét, ahol minden állítás ténylegesen egy megadott szakaszra hivatkozik. Ez az érték a kiindulópontod; minden ezt követő optimalizálást ehhez viszonyítva kell megítélni, nem pedig két-három véletlenszerűen elolvasott válasz benyomása alapján.

Főbb megállapítások

  • A RAP automatizálja a releváns kontextus promptba történő beszúrását
  • A darabolás kritikus: kísérletezz különböző méretekkel
  • Az LLM-mel végzett újrarendezés jelentősen javítja a relevanciát
  • A HyDE akkor hasznos, ha a kérdés szókincse nagyban eltér a dokumentumokétól
  • Az OpenAI File Search leegyszerűsíti a telepítést szabványos esetekben