Przejdź do głównej treści
Polski— Wybierz język
Menu

Promptowanie wspomagane wyszukiwaniem (RAG)

Lekcja 9 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Promptowanie wspomagane wyszukiwaniem
  2. Architektura systemu RAP
  3. Kompletny potok
  4. Chunking: dzielenie dokumentów
  5. Zaawansowane strategie wyszukiwania
  6. Korzystanie z natywnego wyszukiwania plików OpenAI
  7. Ustal punkt odniesienia
  8. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 na podstawie dokumentacji OpenAI: parametry temperature i top_p są akceptowane wyłącznie przy wysiłku rozumowania (reasoning effort) ustawionym na none, podczas gdy modele GPT-5.6 domyślnie przeprowadzają rozumowanie (medium). Wywołania ustawiające te parametry muszą zatem określać reasoning={"effort": "none"} (Responses API) lub reasoning_effort="none" (Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.

Promptowanie wspomagane wyszukiwaniem

Promptowanie wspomagane wyszukiwaniem (ang. Retrieval-Augmented Prompting, RAP) łączy wyszukiwanie dokumentów z tworzeniem promptów, aby dostarczyć modelowi istotny i aktualny kontekst. Jest to naturalna ewolucja ugruntowania (grounding): zamiast ręcznie wstrzykiwać kontekst, automatyzujesz wyszukiwanie odpowiednich fragmentów przed każdym wywołaniem LLM.

Różnica staje się oczywista na dużą skalę. Ręczne wklejanie trzech przydatnych akapitów z dokumentacji sprawdza się w przypadku demonstracji, ale gdy baza dokumentacji osiągnie kilka setek stron, a pytania będą napływać ciągle, nikt nie będzie już wiedział, które fragmenty wkleić. RAP deleguje ten wybór do automatycznego komponentu, uruchamianego przed każdym generowaniem, którego jedyną rolą jest znalezienie tego, co powinno trafić do promptu.

Architektura systemu RAP

Potok RAP dzieli się na trzy kroki działające z różną prędkością i kosztem. Indeksowanie przekształca Twoje dokumenty w wektorowe osadzenia (embeddings); dzieje się to raz, offline, zamieniając każdy dokument w wektor numeryczny kodujący jego znaczenie, przechowywany wraz z oryginalnym tekstem. Wyszukiwanie z kolei uruchamia się przy każdym pytaniu: przekształcasz pytanie w wektor za pomocą tego samego modelu osadzania, a następnie wyszukujesz najbliższe wektory dokumentów. Na koniec augmentacja to po prostu standardowe promptowanie – budujesz prompt systemowy zawierający pobrane fragmenty i instruujesz model, aby nie wychodził poza ten zakres.

Zapamiętaj ten podział: wszystko, co kosztowne, dzieje się podczas indeksowania, gdzie możesz sobie pozwolić na wymagające operacje, podczas gdy wszystko, co powtarza się dla każdego pytania, musi pozostać szybkie. Poniższy kod implementuje pierwsze dwa kroki, używając podobieństwa cosinusowego jako miary bliskości.

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

Kompletny potok

Złożenie tych elementów budulcowych daje klasę mieszczącą się w około trzydziestu liniach. Większość decyzji zapada w generowanym prompcie systemowym i warto przeczytać go linijka po linijce. Model najpierw otrzymuje polecenie odpowiadania WYŁĄCZNIE na podstawie dostarczonych fragmentów, co ogranicza halucynacje, gdy dokumentacja milczy na dany temat. Następnie otrzymuje instrukcję cytowania numeru fragmentu dla każdego twierdzenia – to właśnie umożliwia weryfikację: recenzent może błyskawicznie dotrzeć do źródła. Wartość temperature równa 0.1 kończy konfigurację – przy odpowiedzi zakotwiczonej w dokumentach kreatywność jest błędem.

class RAGPipeline:
    """Minimalistyczny potok 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:
        """Odpowiada na pytanie na podstawie dokumentów."""
        # Wyszukiwanie
        relevant_docs = retrieve(
            question, self.documents,
            self.embeddings, top_k
        )

        # Augmentacja 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}"""

        # Generowanie
        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: dzielenie dokumentów

Dzielenie dokumentów na fragmenty (chunki) jest kluczowe dla jakości wyszukiwania. Jeśli fragmenty są zbyt duże, toną w nich istotne informacje; jeśli zbyt małe, tracą kontekst. Podręcznik API podzielony na dziesięciostronicowe bloki zawsze zwróci ten sam ogólny blok, niezależnie od zadanego pytania. Podzielony na izolowane zdania, zwróci zdanie zaczynające się od „ta metoda“, bez wiedzy modelu, o jaką metodę chodzi. Nakładanie się (overlap) specyficznie łagodzi to ryzyko: każdy fragment powtarza koniec poprzedniego, dzięki czemu informacje przechodzące przez granicę pozostają czytelne przynajmniej z jednej strony.

Gdy Twoje dokumenty mają strukturę nagłówków, chunking oparty na sekcjach jest prawie zawsze lepszy niż chunking o stałym rozmiarze: sekcja „Uwierzytelnianie“ pozostaje nienaruszona, wraz ze wstępem i przykładami.

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

Zaawansowane strategie wyszukiwania

Ponowne rankingowanie (Reranking)

Po wstępnym wyszukiwaniu użyj LLM do ponownego uporządkowania wyników. Logika jest taka jak w lejku: wyszukiwanie wektorowe jest szybkie, ale przybliżone, zwracając tuzin prawdopodobnych kandydatów; model, wolniejszy, ale bardziej wyrafinowany, ponownie czyta tych kandydatów znając pytanie i rankinguje ich. Następnie zachowujesz tylko szczyt listy do generowania. Zysk jest najbardziej widoczny przy pytaniach, gdzie kilka fragmentów mówi o tym samym temacie, ale tylko jeden faktycznie na nie odpowiada – trzy sekcje wspominają słowo „limit“, ale tylko jedna wyjaśnia, jak go podnieść.

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

Hipotetyczne osadzanie dokumentów (HyDE)

Wygeneruj idealny hipotetyczny dokument, a następnie wyszukaj podobne dokumenty. Problem, który rozwiązuje ta technika, to niedopasowanie słownictwa: pytanie zadane językiem potocznym nie wygląda wektorowo jak akapit dokumentacji technicznej. Prosząc najpierw model o napisanie odpowiedzi, jaką sobie wyobraża, otrzymujesz tekst napisany rejestrem Twoich dokumentów i to właśnie ten tekst używasz jako zapytania. Nie ma znaczenia, czy hipotetyczny akapit zawiera przybliżenia: nigdy nie służy jako odpowiedź, a jedynie 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)

Korzystanie z natywnego wyszukiwania plików OpenAI

Do szybkiego wdrożenia API oferuje zintegrowane wyszukiwanie. Przesyłasz plik, tworzysz magazyn wektorowy, dołączasz do niego plik i deklarujesz narzędzie file_search w wywołaniu: chunking, osadzanie i wyszukiwanie są obsługiwane po stronie serwera. Jest to właściwy wybór, gdy Twoje dokumenty są standardowe i nie obchodzi Cię, gdzie dane są przechowywane. Własny potok zachowuje przewagę, gdy tylko potrzebujesz opanować chunking, hostować indeks samodzielnie lub podpiąć specyficzne ponowne rankingowanie.

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

Ustal punkt odniesienia

Weź od pięciu do dziesięciu stron dokumentacji technicznej i zaimplementuj kompletny potok, od chunkingu do generowania. Napisz dziesięć pytań, na które odpowiedzi znajdują się w dokumentach, uruchom potok dla każdego z nich, a następnie powtórz proces z włączonym ponownym rankingowaniem: obserwując, przy których pytaniach ranking się zmienia, zrozumiesz, czego samo wyszukiwanie wektorowe nie wyłapuje. Zakończ, mierząc procent poprawnie zakotwiczonych odpowiedzi, czyli takich, gdzie każde twierdzenie faktycznie odnosi się do dostarczonego fragmentu. Ta liczba jest Twoim punktem startowym; wszystkie kolejne optymalizacje będą oceniane w odniesieniu do niej, a nie do wrażenia pozostawionego przez dwa czy trzy losowo przeczytane odpowiedzi.

Kluczowe wnioski

  • RAP automatyzuje wstrzykiwanie istotnego kontekstu do promptu
  • Chunking jest krytyczny: eksperymentuj z różnymi rozmiarami
  • Ponowne rankingowanie za pomocą LLM znacząco poprawia trafność
  • HyDE jest przydatne, gdy pytanie сильно różni się słownictwem od dokumentów
  • OpenAI File Search upraszcza wdrożenie w standardowych przypadkach