Salt la conținutul principal
Română— Alege o limbă
Meniu

Prompting augmentat prin recuperare

Lecția 9 din 16 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Prompting augmentat prin recuperare
  2. Arhitectura unui sistem RAP
  3. Pipeline complet
  4. Chunking: divizarea documentelor
  5. Strategii avansate de recuperare
  6. Utilizarea căutării native de fișiere OpenAI
  7. Stabilirea unei linii de bază
  8. Puncte cheie

Lecție actualizată la 3 noiembrie 2026 pe baza documentației OpenAI: parametrii temperature și top_p sunt acceptați doar cu un efort de raționament de none, în timp ce modelele GPT-5.6 raționează implicit (medium). Apelurile care setează acești parametri trebuie, prin urmare, să specifice reasoning={"effort": "none"} (Responses API) sau reasoning_effort="none" (Chat Completions). Surse: Utilizarea GPT-6 · GPT-5.6 Terra.

Prompting augmentat prin recuperare

Prompting-ul Augmentat prin Recuperare (RAP) combină căutarea în documente cu generarea de prompturi pentru a oferi modelului un context relevant și actualizat. Reprezintă evoluția naturală a ancorării (grounding): în loc să injectați manual contextul, automatizați căutarea pasajelor relevante înainte de fiecare apel către LLM.

Diferența devine evidentă la scară largă. Lipirea manuală a trei paragrafe utile din documentația dumneavoastră funcționează pentru o demonstrație; însă, odată ce baza documentară atinge câteva sute de pagini și întrebările sosesc continuu, nimeni nu mai știe ce pasaje să lipească. RAP deleagă această alegere unei componente automate, apelată înainte de fiecare generare, al cărei singur rol este să găsească ce trebuie inclus în prompt.

Arhitectura unui sistem RAP

Un pipeline RAP se descompune în trei pași care operează la viteze și costuri diferite. Indexarea transformă documentele dumneavoastră în embedding-uri vectoriale; acest lucru se întâmplă o singură dată, offline, transformând fiecare document într-un vector numeric care îi codifică sensul, stocat alături de textul original. Recuperarea, dimpotrivă, rulează la fiecare întrebare: transformați întrebarea într-un vector folosind același model de embedding, apoi căutați vectorii documentelor cele mai apropiate. În final, augmentarea este doar un prompting standard — construiți un prompt de sistem care conține pasajele recuperate și instruiți modelul să nu iasă din acest perimetru.

Rețineți această diviziune: tot ce este costisitor se întâmplă în timpul indexării, unde vă puteți permite să fiți exigenți, în timp ce tot ce se repetă pentru fiecare întrebare trebuie să rămână rapid. Codul de mai jos implementează primii doi pași, folosind similaritatea cosinusului ca măsură de proximitate.

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]]

Pipeline complet

Asamblarea acestor blocuri de construcție rezultă într-o clasă care se încadrează în aproximativ treizeci de linii. Majoritatea deciziilor au loc în promptul de sistem generat și merită citit linie cu linie. Modelul primește mai întâi ordinul de a răspunde DOAR pe baza pasajelor furnizate, ceea ce limitează răspunsurile halucinate atunci când documentația este mută. Primește apoi instrucțiunea de a cita numărul pasajului pentru fiecare afirmație, iar acesta este lucrul care face posibilă verificarea: un recenzor poate urmări sursa dintr-o singură privire. O valoare temperature de 0.1 completează configurarea — pentru un răspuns ancorat în documente, creativitatea este un bug.

class RAGPipeline:
    """Minimalist RAP pipeline."""

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

    def query(self, question: str, top_k: int = 3) -> str:
        """Answers a question based on the documents."""
        # Retrieval
        relevant_docs = retrieve(
            question, self.documents,
            self.embeddings, top_k
        )

        # Prompt augmentation
        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}"""

        # Generation
        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: divizarea documentelor

Divizarea documentelor în chunk-uri (fragmente) este crucială pentru calitatea recuperării. Dacă chunk-urile sunt prea mari, ele înecă informația relevantă; dacă sunt prea mici, pierd contextul. Un manual API divizat în blocuri de zece pagini va returna întotdeauna același bloc generic, indiferent de întrebarea pusă. Divizat în propoziții izolate, va returna o propoziție care începe cu „această metodă“, fără ca modelul să știe la ce metodă se referă. Suprapunerea mitigează specific acest risc: fiecare chunk repetă sfârșitul celui precedent, astfel încât informația care traversează o frontieră rămâne lizibilă din cel puțin o parte.

Când documentele dumneavoastră au o structură de anteturi, chunking-ul bazat pe secțiuni este aproape întotdeauna superior chunking-ului de dimensiune fixă: o secțiune „Autentificare“ rămâne intactă, cu introducerea și exemplele sale.

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

Strategii avansate de recuperare

Reclasificare (Reranking)

După recuperarea inițială, utilizați LLM pentru a reordona rezultatele. Logica este cea a unei pâlnii: căutarea vectorială este rapidă, dar aproximativă, aducând înapoi o duzină de candidați plauzibili; modelul, mai lent dar mai nuanțat, recitește acești candidați cunoscând întrebarea și îi clasează. Păstrați apoi doar vârful listei pentru generare. Câștigul este cel mai vizibil la întrebările unde mai multe pasaje vorbesc despre același subiect, dar doar unul răspunde efectiv — trei secțiuni menționează cuvântul „cotă“, dar doar una explică cum să o măriți.

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

Embedding de Documente Ipotetice (HyDE)

Generați un document ipotetic ideal, apoi căutați documente similare. Problema pe care o rezolvă această tehnică este nepotrivirea vocabularului: o întrebare formulată în limbaj curent nu arată, din punct de vedere vectorial, ca un paragraf de documentație tehnică. Cerând mai întâi modelului să scrie răspunsul pe care și-l imaginează, obțineți un text redactat în registrul documentelor dumneavoastră, iar acest text este cel pe care îl utilizați ca interogare. Nu contează dacă paragraful ipotetic conține aproximări: acesta nu servește niciodată drept răspuns, ci doar ca sondă.

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)

Utilizarea căutării native de fișiere OpenAI

Pentru o implementare rapidă, API-ul oferă recuperare integrată. Încărcați fișierul, creați un stoc vectorial, atașați fișierul la acesta și declarați instrumentul file_search în apel: chunking-ul, embedding-ul și căutarea sunt gestionate lato-server. Aceasta este alegerea corectă atunci când documentele dumneavoastră sunt standard și nu vă interesează unde locuiesc datele. Pipeline-ul propriu păstrează avantajul imediat ce aveți nevoie să stăpâniți chunking-ul, să găzduiți indexul dumneavoastră sau să conectați o reclasificare specifică.

# 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]
    }]
)

Stabilirea unei linii de bază

Luați cinci până la zece pagini de documentație tehnică și implementați pipeline-ul complet, de la chunking la generare. Scrieți zece întrebări ale căror răspunsuri se află în documente, rulați pipeline-ul pentru fiecare, apoi repetați cu reclasificarea activată: observând la care întrebări se schimbă clasamentul, veți înțelege ce pierde căutarea vectorială singură. Terminați prin măsurarea procentului de răspunsuri corect ancorate, acelea unde fiecare afirmație se referă efectiv la un pasaj furnizat. Această cifră este punctul dumneavoastră de plecare; toate optimizările ulterioare vor fi judecate în raport cu aceasta, nu cu impresia lăsată de două sau trei răspunsuri citite aleatoriu.

Puncte cheie

  • RAP automatizează injectarea contextului relevant în prompt
  • Chunking-ul este critic: experimentați cu dimensiuni diferite
  • Reclasificarea cu LLM îmbunătățește semnificativ relevanța
  • HyDE este util atunci când întrebarea diferă foarte mult de vocabularul documentelor
  • OpenAI File Search simplifică implementarea pentru cazurile standard