Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Prompting imsaħħaħ bir-riċerka

Lezzjoni 9 / 16 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Prompting imsaħħaħ bir-riċerka
  2. Arkitettura ta’ sistema RAP
  3. Pipeline sħiħa
  4. Chunking: qsim tad-dokumenti
  5. Strateġiji avvanzati ta’ riċerka
  6. L-użu tat-Tfittxija tal-Fajls nattiva ta’ OpenAI
  7. Stabbilixxi linja bażi
  8. Punti Ewlenin

Lezzjoni aġġornata fit-3 ta’ Novembru 2026 ibbażata fuq id-dokumentazzjoni ta’ OpenAI: temperature u top_p huma aċċettati biss b’sforz ta’ raġunament ta’ none, filwaqt li l-mudelli GPT-5.6 jirraġunaw b’mod awtomatiku (medium). Għalhekk, is-sejħiet li jistabbilixxu dawn il-parametri jridu jispeċifikaw reasoning={"effort": "none"} (API tar-Risposti) jew reasoning_effort="none" (Chat Completions). Sorsi: L-użu ta’ GPT-6 · GPT-5.6 Terra.

Prompting imsaħħaħ bir-riċerka

Il-Prompting Imsaħħaħ bir-Riċerka (RAP) jgħaqqad it-tfittxija tad-dokumenti mal-prompting biex jipprovdi lill-mudell kuntest rilevanti u aġġornat. Din hija l-evoluzzjoni naturali tal-”grounding”: minflok ma tinjetta l-kuntest manwalment, tawtomatizza t-tfittxija għal passi rilevanti qabel kull sejħa tal-LLM.

Id-differenza ssir ovvja fuq skala kbira. Li twaħħal manwalment tliet paragrafi utli mid-dokumentazzjoni tiegħek jaħdem għal demo; iżda ladarba l-bażi tad-dokumentazzjoni tiegħek tilħaq ftit mijiet ta’ paġni u l-mistoqsijiet jaslu kontinwament, ħadd ma jaf aktar liema passi għandu jwaħħal. Ir-RAP jiddelega din il-għażla lil komponent awtomatiku, imsejjaħ qabel kull ġenerazzjoni, li r-rwol uniku tiegħu huwa li jsib x’għandu jitpoġġa fil-prompt.

Arkitettura ta’ sistema RAP

Pipeline RAP tinqasam f’tliet passi li joperaw b’veloċitajiet u spejjeż differenti. L-indiċjar jittrasforma d-dokumenti tiegħek f’embeddings vettorjali; dan iseħħ darba biss, offline, u jbiddel kull dokument f’vettur numeriku li jikkodifika t-tifsira tiegħu, maħżun flimkien mat-test oriġinali. Ir-riċerka, min-naħa l-oħra, tiġri fuq kull mistoqsija: tittrasforma l-mistoqsija f’vettur bl-użu tal-istess mudell ta’ embedding, imbagħad tfittex l-eqreb vetturi tad-dokumenti. Fl-aħħar nett, it-tisħiħ huwa sempliċiment prompting standard—tibni prompt tas-sistema li fih il-passi rkuprati u tgħid lill-mudell biex ma joħroġx minn dan l-ambitu.

Ftakar f’din id-diviżjoni: kollox li huwa għali jseħħ waqt l-indiċjar, fejn tista’ taffordja li tkun eżiġenti, filwaqt li kollox li jirrepeti ruħu għal kull mistoqsija jrid jibqa’ mgħaġġel. Il-kodiċi hawn taħt jimplimenta l-ewwel żewġ passi bl-użu tas-similarità tal-kożinu bħala miżura tal-prossimità.

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 sħiħa

L-assemblaġġ ta’ dawn il-blokki tal-bini jipproduċi klassi li tidħol f’madwar tletin linja. Il-biċċa l-kbira tad-deċiżjonijiet iseħħu fil-prompt tas-sistema ġġenerat, u jixraq li taqra linja b’linja. L-ewwel nett, il-mudell jirċievi l-ordni biex iwieġeb BISS mill-passi pprovduti, li tillimita t-tweġibiet alluċinati meta d-dokumentazzjoni tkun siekta. Imbagħad jirċievi l-istruzzjoni biex jikkita n-numru tal-passaġġ għal kull affermazzjoni, u dan huwa dak li jagħmel il-verifika possibbli: reviżur jista’ jmur lura għas-sors f’daqqa t’għajn. temperature ta’ 0.1 tlesti l-installazzjoni—fuq tweġiba mwaħħla ma’ dokumenti, il-kreattività hija 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: qsim tad-dokumenti

Il-qsim tad-dokumenti f’biċċiet (chunks) huwa kruċjali għall-kwalità tar-riċerka. Jekk il-biċċiet ikunu kbar wisq, jegħrqu l-informazzjoni rilevanti; jekk ikunu żgħar wisq, jitilfu l-kuntest. Manwal tal-API maqsum f’blokok ta’ għaxar paġni dejjem se jirritorna l-istess blokk ġeneriku, irrispettivament mill-mistoqsija magħmula. Jekk jinqasam f’sentenzi iżolati, se jirritorna sentenza li tibda b‘“din il-metodu” mingħajr ma l-mudell ikun jaf liema metodu qed jirreferi għalih. L-overlap speċifikament jimmitiga dan ir-riskju: kull biċċa tirrepeti t-tmiem ta’ dik ta’ qabilha, sabiex l-informazzjoni li taqsam il-fruntiera tibqa’ leġibbli mill-inqas minn naħa waħda.

Meta d-dokumenti tiegħek ikollhom struttura ta’ intestaturi, il-qsim ibbażat fuq it-taqsimiet huwa kważi dejjem superjuri għall-qsim b’daqs fiss: taqsima dwar l-”Awtentikazzjoni” tibqa’ intatta, flimkien mal-introduzzjoni u l-eżempji tagħha.

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

Strateġiji avvanzati ta’ riċerka

Reranking (Klassifikazzjoni mill-ġdid)

Wara r-riċerka inizjali, uża l-LLM biex terġa’ tordna r-riżultati. Il-loġika hija dik ta’ funnel: it-tfittxija vettorjali hija mgħaġġla iżda approssimattiva, u ġġib lura dożġina ta’ kandidati plawżibbli; il-mudell, aktar bil-mod iżda aktar sfumata, jerġa’ jaqra dawn il-kandidati billi jaf il-mistoqsija u jikklassifikahom. Imbagħad iżżomm biss il-quċċata tal-lista għall-ġenerazzjoni. Il-qligħ huwa l-aktar viżibbli fuq mistoqsijiet fejn diversi passi jitkellmu dwar l-istess suġġett iżda wieħed biss fil-fatt iwieġebha—tliet taqsimiet isemmu l-kelma “kwota”, iżda waħda biss tispjega kif tgħolliha.

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

Hypothetical Document Embedding (HyDE)

Iġġenera dokument ipotetiku ideali, imbagħad fittex dokumenti simili. Il-problema li ssolvi din it-teknika hija d-diskrepanza fil-vokabolarju: mistoqsija mistoqsija bil-lingwa ta’ kuljum ma tidhirx, vettorjalment, bħal paragrafu ta’ dokumentazzjoni teknika. Billi l-ewwel titlob lill-mudell jikteb it-tweġiba li jimmaġina, tikseb test miktub fir-reġistru tad-dokumenti tiegħek, u huwa dan it-test li tuża bħala l-mistoqsija. Mhuwiex importanti jekk il-paragrafu ipotetiku fihx approssimazzjonijiet: qatt ma jservi bħala t-tweġiba, iżda biss bħala 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)

L-użu tat-Tfittxija tal-Fajls nattiva ta’ OpenAI

Għal dispjegament rapidu, l-API toffri riċerka integrata. Ittella’ l-fajl, toħloq maħżen vettorjali, twaħħal il-fajl miegħu, u tiddikjara l-għodda file_search fis-sejħa: il-qsim, l-embedding u t-tfittxija jiġu ġestiti fuq is-server. Din hija l-għażla t-tajba meta d-dokumenti tiegħek huma standard u ma tħabbtikx fejn qed tgħix id-data. Il-pipeline magħmul id-dar iżomm il-vantaġġ ladarba jkollok bżonn tikkontrolla l-qsim, tospita l-indiċi int stess, jew tħaddem klassifikazzjoni mill-ġdid speċifika.

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

Stabbilixxi linja bażi

Ħu bejn ħames u għaxar paġni ta’ dokumentazzjoni teknika u implimenta l-pipeline sħiħa, mill-qsim sal-ġenerazzjoni. Ikteb għaxar mistoqsijiet li t-tweġibiet tagħhom jinsabu fid-dokumenti, ġarri l-pipeline fuq kull waħda, imbagħad erġa’ agħmel dan bir-reranking attiv: huwa billi tosserva fuq liema mistoqsijiet tinbidel il-klassifikazzjoni li tifhem x’qed titlef it-tfittxija vettorjali waħedha. Ikkonkludi billi tkejjel il-perċentwal ta’ tweġibiet imwaħħla korrettament, dawk fejn kull affermazzjoni tirreferi effettivament għal passaġġ ipprovdut. Din iċ-ċifra hija l-punt tat-tluq tiegħek; l-ottimizzazzjonijiet sussegwenti kollha jiġu ġġudikati kontra din, mhux kontra l-impressjoni li jħallu żewġ jew tliet tweġibiet moqrija b’mod każwali.

Punti Ewlenin

  • Ir-RAP jawtomatizza l-injezzjoni ta’ kuntest rilevanti fil-prompt
  • Il-qsim (chunking) huwa kritiku: esperimenta b’daqsijiet differenti
  • Ir-reranking bl-LLM itejjeb b’mod sinifikanti r-rilevanza
  • HyDE huwa utli meta l-mistoqsija tkun differenti ħafna mill-vokabolarju tad-dokumenti
  • It-Tfittxija tal-Fajls ta’ OpenAI tissimplifika d-dispjegament għal każijiet standard