Einföld RAG-innleiðing: leiðbeiningar skref fyrir skref

RAG er ómissandi hluti nútímalegra innviða sem byggja á mállíkönum (LLM). Með því að veita gervigreindarlíkönum aðgang að ytri gögnum hjálpar það til við að taka á vandamálum á borð við ofskynjanir og ófullnægjandi þjálfunargögn. Það gerir fyrirtækjum einnig kleift að nýta innri þekkingargrunna sem innihalda viðkvæmar upplýsingar eða upplýsingar í einkaeigu.

Innleiðing RAG getur verið mjög flókin. Hins vegar er furðu auðvelt að smíða einfalt RAG-kerfi. Fyrir byrjendur getur einföld uppbygging varpað ljósi á hvernig RAG virkar í raun og veru og verið stökkpallur fyrir frekari tilraunir.

Í þessari grein förum við yfir einfalda RAG-innleiðingu, fjöllum um bestu starfsvenjur og smíðum síðan starfhæft kerfi með Python, ChromaDB og tveimur líkönum frá Perplexity, annars vegar fyrir innfellingu og hins vegar fyrir gerð svara.

Einfalt RAG-kerfi samanstendur af þremur meginþáttum: stýringu (orchestrator), upplýsingaveitu og mállíkani (LLM). Í dæmigerðu verkflæði slær notandi inn kvaðningu og stýringin aðlagar hana til að leita í tengdum upplýsingaveitum. Upplýsingunum sem eru sóttar er síðan bætt við upprunalega inntakssamhengið og þær sendar til mállíkansins svo hægt sé að búa til svar.

Þú þarft að gera ráð fyrir eftirfarandi skrefum þegar þú smíðar RAG-innleiðinguna þína:

Lyklun og innfelling: Á þessu stigi er skjölunum þínum breytt í upplýsingaveitu sem stýringin getur leitað í. Ein algengasta leiðin til þess er að smíða leitarhæfan vigurvísi. Við notum sérhæft líkan frá Perplexity til að breyta skjalabútunum þínum í innfellingar. Síðan geymum við innfellingarnar í ChromaDB, vinsælum vigurgagnagrunni með opnum frumkóða.
Stýring: Þetta er forritið sem situr á milli ytri upplýsingaveitunnar (vigurgagnagrunns í okkar tilviki) og mállíkansins. Við búum til einfalda Python-skriftu sem gegnir hlutverki stýringarinnar.
Upplýsingasókn og gerð svara: Þegar notandi spyr spurningar í gegnum spjallviðmótið tekur stýringin við henni, framkvæmir vigurleit og sendir útvíkkaða inntakið til mállíkansins. Við notum skipanalínuna til að eiga samskipti við Python-stýringuna okkar í stað þess að smíða sérstakt framendaviðmót.

Til eru margar gerðir RAG-arkitektúrs og ólík notkunartilvik kalla á ólíkar nálganir. Engu að síður eiga ýmsar bestu starfsvenjur við í öllum tilvikum og tryggja nákvæm, hagkvæm, skalanleg og viðhaldsvæn kerfi.

Eftirfarandi bestu starfsvenjur eiga við um allar gerðir RAG-innleiðinga:

Tryggðu hreina innlestrarleiðslu: Upprunagögnin þín ættu að vera eins hrein og mögulegt er áður en þau eru lykluð. Þú ættir einnig að nota innfellingarlíkan sem hentar efninu þínu.
Notaðu blandaða leit: Bestu aðferðirnar við upplýsingasókn, hvort sem um er að ræða leit í vigurgagnagrunni, vefleit í gegnum API, yfirferð þekkingargrafs, lykilorðaleit eða aðrar aðferðir, eru breytilegar eftir notkunartilvikum. Mikilvægt er að velja rétta blöndu til að halda kostnaði í lágmarki.
Mettu kerfið þitt: Að innleiðingu lokinni ættir þú að meta kerfið út frá þremur meginmælikvörðum: nákvæmni, mikilvægi og biðtíma. Nákvæmni vísar til þess hvort staðreyndir séu réttar, mikilvægi til þess hversu vel sóttu upplýsingarnar eiga við fyrirspurnir notenda og biðtími til þess hversu hratt upplýsingarnar eru sóttar.
Meðhöndlaðu upplýsingar á öruggan hátt: Ef RAG-kerfið þitt byggir á lokuðum innri upplýsingum skaltu tryggja að þær séu geymdar á öruggan hátt og að aðgangi að viðmóti kerfisins sé stýrt. Aldrei ætti að deila API-lyklum.

Í þessum leiðbeiningum smíðum við skipanalínuforrit sem svarar spurningum um eitt skjal. Við notum Python, ChromaDB og Perplexity API.

Markmiðið er ekki að smíða RAG-kerfi sem er tilbúið í rekstur. Þetta eru öllu heldur byrjendavænar leiðbeiningar sem eiga að sýna hvernig einfaldur RAG-arkitektúr virkar í reynd.

Gakktu úr skugga um að eftirfarandi sé uppsett á tölvunni þinni og að þú sért með aðgang að Perplexity API:

Python: Þetta er forritunarmálið sem við notum til að smíða stýringuna sem samhæfir gagnaflæðið milli innfellingarlíkansins, ChromaDB og Perplexity.
Visual Studio: Við notum Visual Studio sem kóðaritil. Þegar uppsetningu er lokið skaltu opna Extensions-svæðið og sækja Python-viðbótina.
Aðgangur að Perplexity API: Perplexity leggur bæði til innfellingarlíkanið (sem breytir gögnunum þínum í vigurinnfellingar) og mállíkanið sem vinnur úr útvíkkuðu kvaðningunni. Þú þarft ekki greiddan aðgang til þess, þótt það kosti fáeinar einingar.

Byrjaðu á því að búa til möppu sem heitir rag-project og opna hana í VS Code með því að velja File > Open Folder. Opnaðu síðan innbyggðu útstöðina með Terminal > New Terminal.

Sláðu inn eftirfarandi til að búa til sýndarumhverfi fyrir Python:

bash

py -3.12 -m venv .venv

Nú þarftu að setja upp fjögur Python-söfn: perplexityai, chromadb, python-dotenv og numpy. Perplexity SDK gerir þér kleift að tengjast líkönum Perplexity í gegnum API. ChromaDB smíðar vigurgagnagrunninn og keyrir á tölvunni þinni. Python-dotenv hleður API-lyklunum þínum á öruggan hátt úr staðbundinni skrá og NumPy er nauðsynlegt í innlestrarferlinu.

Settu þau upp með eftirfarandi skipun:

bash

.\.venv\Scripts\python.exe -m pip install perplexityai chromadb python-dotenv numpy

Bættu eftirfarandi skrám við rag-project (rót verkefnisins) með því að velja New File… í Explorer-hliðarstikunni:

index.py: Þetta er forritið sem lyklar skjalið þitt. Þú getur keyrt það aftur til að bæta við meiri texta.
rag.py: Þetta er Python-forritið sem gegnir hlutverki stýringarinnar.
document.txt: Þessi skrá mun innihalda textann sem þú breytir í vigurgagnagrunn.
.env: Hér geymir þú API-lykilinn þinn fyrir Perplexity.

Sláðu inn eftirfarandi í .env:

plaintext

PERPLEXITY_API_KEY=your_api_key_here

Skiptu your_api_key_here út fyrir raunverulega lykilinn þinn. Til þess þarftu að fara á yfirlitssíðu Perplexity API Console og velja Create an API key. Haltu þessum API-lykli leyndum.

Yfirlitssíða Perplexity API Console sem sýnir inneign upp á $10.00, hnappinn Create API key og spjöld fyrir API-in Orchestrator, Agent, Search, Embeddings og Decisions.

Við notum tvö líkön: pplx-embed-v1-0.6b frá Perplexity til að fella inn textann okkar áður en hann er hlaðinn upp í ChromaDB og GPT-5.6-Luna (sem er aðgengilegt í gegnum API Perplexity), sem vinnur úr upplýsingunum sem eru sóttar.

Bættu textanum sem RAG-leiðslan þín á að sækja við document.txt. Ef þú ert ekki með skjal við höndina geturðu notað Songs of Innocence and of Experience eftir William Blake frá Project Gutenberg fyrir þessar leiðbeiningar. Þetta er stuttur og auðskiljanlegur texti sem er í almenningseigu.

Afritaðu kóðann hér að neðan og límdu hann inn í index.py. Hver millifyrirsögn útskýrir í stuttu máli hvað kóðabúturinn sem fylgir gerir. Þetta er forritið sem breytir upprunaefninu þínu í vigurinnfellingar og geymir þær í ChromaDB-gagnagrunni með innfellingarlíkani Perplexity, pplx-embed-v1-0.6b, og NumPy-safninu.

Þetta gerir forritið:

Opnar document.txt.
Skiptir textanum í búta sem skarast.
Sendir þessa búta í innfellingarlíkanið pplx-embed-v1-0.6b frá Perplexity.
Afkóðar og normar vigrana sem berast til baka með NumPy, Python-safni með reikniföllum.
Geymir vigrana og upprunalegu bútana í ChromaDB-gagnagrunni (hann birtist í verkefnismöppunni þinni).

Forritið er sett upp þannig að það lykli skjalið þitt ekki upp á nýtt í hvert skipti sem þú keyrir það. Ef þú bætir við upplýsingarnar í document.txt fellir það aðeins inn nýja textann.

python

from pathlib import Path
from collections import defaultdict, deque
from hashlib import sha256
import base64
import numpy as np
import chromadb
from dotenv import load_dotenv
from perplexity import Perplexity
# 1. Connect to Perplexity and ChromaDB
load_dotenv()
ai = Perplexity()
db = chromadb.PersistentClient(path="./rag_database_perplexity")
collection = db.get_or_create_collection(
    name="documents",
    metadata={"hnsw:space": "cosine"}
)
# Convert Perplexity's encoded embeddings into numerical vectors
def decode_embedding(encoded):
    vector = np.frombuffer(base64.b64decode(encoded), dtype=np.int8).astype(np.float32)
    norm = np.linalg.norm(vector)
    if norm == 0:
        raise ValueError("Received a zero-length embedding vector.")
    return (vector / norm).tolist()
# 2. Read the document and split it into chunks
text = Path("document.txt").read_text(encoding="utf-8")
words = text.split()
chunk_size = 180
overlap = 30
step = chunk_size - overlap
chunks = [" ".join(words[i:i + chunk_size]) for i in range(0, len(words), step)]
if not chunks:
    raise ValueError("document.txt is empty.")
# 3. Retrieve the chunks already stored in ChromaDB
existing = collection.get(include=["documents"])
stored_chunks = defaultdict(deque)
existing_ids = set(existing["ids"])
for chunk_id, document in zip(existing["ids"], existing["documents"]):
    stored_chunks[document].append(chunk_id)
# 4. Identify unchanged and new chunks
new_chunks = []
new_ids = []
kept_ids = set()
unchanged = 0
for chunk in chunks:
    if stored_chunks[chunk]:
        chunk_id = stored_chunks[chunk].popleft()
        kept_ids.add(chunk_id)
        unchanged += 1
    else:
        chunk_hash = sha256(chunk.encode("utf-8")).hexdigest()
        chunk_id = f"chunk-{chunk_hash}"
        suffix = 1
        while chunk_id in existing_ids or chunk_id in kept_ids or chunk_id in new_ids:
            chunk_id = f"chunk-{chunk_hash}-{suffix}"
            suffix += 1
        new_chunks.append(chunk)
        new_ids.append(chunk_id)
        kept_ids.add(chunk_id)
# 5. Generate embeddings in batches of up to 100 chunks
batch_size = 100
for i in range(0, len(new_chunks), batch_size):
    batch_chunks = new_chunks[i:i + batch_size]
    batch_ids = new_ids[i:i + batch_size]
    embeddings = ai.embeddings.create(
        model="pplx-embed-v1-0.6b",
        input=batch_chunks,
        encoding_format="base64_int8"
    )
    vectors = [decode_embedding(item.embedding) for item in embeddings.data]
    # 6. Store each batch in ChromaDB
    collection.upsert(
        ids=batch_ids,
        documents=batch_chunks,
        embeddings=vectors
    )
    print(f"Indexed batch {(i // batch_size) + 1}")
# 7. Remove outdated chunks
old_ids = [chunk_id for chunk_id in existing["ids"] if chunk_id not in kept_ids]
if old_ids:
    collection.delete(ids=old_ids)
# 8. Display indexing results
print("Indexing complete!")
print("Unchanged chunks:", unchanged)
print("New or modified chunks:", len(new_chunks))
print("Removed chunks:", len(old_ids))
print("Total stored chunks:", collection.count())

Afritaðu kóðann hér að neðan og límdu hann inn í rag.py. Þetta er fullbúin en afar einföld RAG-innleiðing sem notar Perplexity SDK og staðbundna vigurgagnagrunnsvirkni ChromaDB.

Þetta gerist þegar þú keyrir forritið:

Tengist Perplexity og nýja ChromaDB-gagnagrunninum þínum.
Kannar hvort gagnagrunnurinn innihaldi lykluð skjöl.
Tekur við spurningu frá notandanum.
Sendir spurninguna í innfellingarlíkan Perplexity.
Afkóðar og normar innfellinguna sem fæst með NumPy.
Leitar í ChromaDB að þeim þremur skjalabútum sem líkjast mest.
Setur saman kvaðningu sem inniheldur bútana sem voru sóttir og spurningu notandans.
Sendir kvaðninguna til GPT-5.6 Luna í gegnum Agent API frá Perplexity.
Birtir svarið og bíður eftir næstu spurningu.

python

import base64
import numpy as np
import chromadb
from dotenv import load_dotenv
from perplexity import Perplexity
# 1. Connect to Perplexity and the existing ChromaDB database
load_dotenv()
ai = Perplexity()
db = chromadb.PersistentClient(path="./rag_database_perplexity")
collection = db.get_collection("documents")
# Convert Perplexity's encoded embeddings into numerical vectors
def decode_embedding(encoded):
    vector = np.frombuffer(base64.b64decode(encoded), dtype=np.int8).astype(np.float32)
    norm = np.linalg.norm(vector)
    if norm == 0:
        raise ValueError("Received a zero-length embedding vector.")
    return (vector / norm).tolist()
# 2. Check that the database contains indexed documents
count = collection.count()
if count == 0:
    raise ValueError("The database is empty. Run index.py first.")
print("Connected to existing ChromaDB database.")
print("Stored chunks:", count)
# 3. Accept questions from the user
while True:
    question = input("\nAsk a question (or type exit): ")
    if question.lower().strip() == "exit":
        break
    if not question.strip():
        continue
    # 4. Convert the question into a Perplexity embedding
    question_response = ai.embeddings.create(
        model="pplx-embed-v1-0.6b",
        input=[question],
        encoding_format="base64_int8"
    )
    question_vector = decode_embedding(question_response.data[0].embedding)
    # 5. Retrieve the most similar document chunks from ChromaDB
    results = collection.query(
        query_embeddings=[question_vector],
        n_results=min(3, count)
    )
    context = "\n\n".join(results["documents"][0])
    # 6. Construct a prompt and send it to the fixed LLM
    response = ai.responses.create(
        model="openai/gpt-5.6-luna",
        instructions=(
            "Answer using only the supplied document excerpts. "
            "Do not use external information. "
            "If the answer is not present, say you don't know."
        ),
        input=f"Document excerpts:\n{context}\n\nQuestion: {question}"
    )
    # 7. Display the answer
    print("\nAnswer:\n", response.output_text)

Sláðu inn eftirfarandi í PowerShell-útstöðinni í VS Code til að fella inn efnið í document.txt:

bash

.\.venv\Scripts\python.exe index.py

Ef tekist hefur að lykla skjalið þitt ætti úttakið að líkjast þessu:

plaintext

Indexing complete!
Unchanged chunks: 0
New or modified chunks: 58
Removed chunks: 0
Total stored chunks: 58

Nú er komið að því að keyra aðalforritið, stýringuna. Sláðu inn þessa skipun:

bash

.\.venv\Scripts\python.exe rag.py

Ef keyrslan heppnast sérðu eftirfarandi:

plaintext

Connected to existing ChromaDB database.
Stored chunks: 58
Ask a question (or type exit):

Nú getur þú spurt spurninga sem byggja á vigurgagnagrunninum sem þú bjóst til, til dæmis:

plaintext

Ask a question (or type exit): What animals does William Blake talk about?
Answer: The excerpts mention sheep, lambs, birds, beasts, wolves, tigers, and a lion.

Kerfið sem þú hefur smíðað inniheldur báðar meginleiðslurnar sem finna má í öllum RAG-arkitektúr: lyklunarleiðslu (eða „innlestrarleiðslu“) og leiðslu fyrir upplýsingasókn og gerð svara.

Einfalda RAG-innleiðingin þín gerir nú allt eftirfarandi:

Vigurgeymsla: Innfellingar eru vistaðar í ChromaDB-gagnagrunninum í staðbundna umhverfinu þínu út frá þekkingarskránni þinni.
Stigvaxandi lyklun: Óbreyttir skjalabútar eru ekki felldir inn aftur og þú getur uppfært skjalið hvenær sem þú vilt.
Merkingarleg upplýsingasókn: ChromaDB sækir búta út frá því hversu líkir vigrarnir eru (að frumkvæði stýringarinnar).
Gerð svara byggð á heimildum: Mállíkanið fær sótta textabúta sem samhengi og fléttar þá inn í svar.
Óháð lyklun og fyrirspurnir: Þú getur spurt spurninga án þess að vinna aftur úr öllum textanum í þekkingarskránni þinni.
Tenging við líkan í gegnum API: Öll svör eru búin til með GPT-5.6 Luna í gegnum Perplexity frekar en með líkani sem keyrir á tölvunni þinni.

Markmiðið með þessum leiðbeiningum er að smíða einfalda og aðgengilega innleiðingu. Hún nær yfir suma af meginþáttum RAG-arkitektúrs sem finna má í nútímakerfum. Ef þú vilt ganga lengra eru ýmsar leiðir til að byggja ofan á hana.

Hér eru nokkrar hugmyndir til að víkka út umfang innleiðingarinnar:

Gerðu tilraunir með LangChain: LangChain er ein vinsælasta stýringarumgjörðin með opnum frumkóða. Hún inniheldur tilbúna íhluti til að smíða forrit sem geta keyrt flóknar RAG-leiðslur.
Víkkaðu út leitarvirknina: Sameinaðu þétta vigurleit og orðaleit (lykilorðaleit) á borð við BM25. Með því að bæta við vefleit í gegnum Perplexity Search API gætirðu einnig byggt svör á nýjustu gögnum.
Bættu við endurröðunarlíkani: Samþættu endurröðunarlíkan sem raðar sóttum textabútum með hliðsjón af upphaflegu kvaðningunni og velur þá sem eiga best við til að hafa með í inntakssamhenginu sem mállíkanið fær.
Smíðaðu aðlögunarhæft RAG-kerfi: Aðlögunarhæft RAG notar annaðhvort mállíkan eða flokkara (íhlut innan stýringarinnar) til að ákvarða hvaða aðferð við upplýsingasókn skuli nota í einingaskiptu RAG-kerfi. Að smíða slíkt kerfi er góð leið til að kynnast þróaðri RAG-innleiðingum.

Þótt þetta geti hljómað flókið skaltu hafa í huga að útbreiddir gervigreindarvettvangar á borð við Perplexity geta veitt öfluga aðstoð við forritun. Þeir henta afar vel fyrir eigin verkefni og tilraunir og hægt er að halda kostnaði tiltölulega lágum.

Athugaðu: Í þessum leiðbeiningum er GPT-5.6 Luna notað. Framboð líkana getur breyst og því gætir þú þurft að uppfæra API-kallið.

Ferlið við einfalda RAG-innleiðingu: almennt yfirlit

Bestu starfsvenjur: Hvað einkennir árangursríka RAG-innleiðingu?

Einföld RAG-innleiðing: leiðbeiningar í 7 skrefum

Skref 1: Settu upp hugbúnað

Skref 2: Búðu til verkefnismöppu

Skref 3: Settu upp skrárnar þínar

Skref 4: Skrifaðu lyklunarforritið

Skref 5. Skrifaðu stýringuna fyrir RAG-kerfið

Skref 6: Keyrðu forritin

Skref 7: Skildu hvað þú hefur smíðað

Næstu skref: hvernig þú getur þróað innleiðinguna lengra