# RAG

RAG (Retrieval-Augmented Generation) on arhitektuur, kus LLM-i vastused tehakse täpsemaks, andes talle enne vastamist juurde infot välisest teadmisteallikast (nt vektoriandmebaas, failid, API). [3][6][14]

### Lihtne seletus

- Sul on suur keelemudel, mis “teab palju”, aga ei tea sinu konkreetseid dokumente või värskeid andmeid. [6][8]
- RAG-süsteem teeb enne vastamist päringu sinu andmehoidlasse (tihti vektorbaasi), otsib semantiliselt sobivad tekstijupid ja lisab need mudeli sisendisse. [5][8][12]
- Mudel genereerib vastuse nende konkreetsete jupikeste põhjal, seega on vastus vähem hallutsineeriv ja rohkem “päris andmetel” põhinev. [4][6][8]

### Kus tuleb mängu “vektor”

- Tekst (küsimus ja dokumendid) teisendatakse embedding’uteks ehk vektoreiks – pikkadeks arvujadadeks, kus lähedased vektorid ≈ sarnase tähendusega tekst. [5][9][11][12]
- Vektorandmebaasist otsitakse küsimuse vektorile kõige lähemad dokumentide vektorid (kosinus-sarnasus jms), need tuuakse välja ja söödetakse mudelile kontekstiks. [5][9][11][12]

Lühidalt: RAG = vektorotsing (retrieval) + LLM-i vastuse genereerimine (generation), kus vektorid on tehniline viis teksti tähendust numbritena esitada ja kiiresti “sama mõttega” tekste üles leida. [5][9][12][14]

Citations:
[1] Tootmisküpsete RAG-põhiste AI-rakenduste ehitamine - Acceli https://www.acceli.ee/blog/building-production-ready-ai-applications-with-rag
[2] Mis on RAG-süsteem ja kuidas see töötab? Põhjalik ... - Tecnoloblog https://www.tecnoloblog.com/et/sistemas-rag/
[3] retrieval-augmented generation - AKIT https://akit.cyber.ee/term/17003-retrieval-augmented-generation
[4] Henrik Aavik's Post - LinkedIn https://www.linkedin.com/posts/henrikaavik_mis-on-rag-ja-miks-see-oluline-on-k%C3%B5ik-activity-7403442746532708352-7GHf
[5] RAG ja Ai4Value älytietokanta - Ai4Value https://ai4value.com/fi/rag-ja-ai4value-alytietokanta/
[6] Mikä on RAG? - alci.dev https://www.alci.dev/fi/que-es/rag
[7] Rag vs. Vektor-Datenbank https://www.reddit.com/r/LocalLLaMA/comments/17qse19/rag_vs_vector_db/
[8] RAG - Tekoälyn sanakirja https://ai-sanakirja.fluentia.fi/rag.html
[9] RAG és vektoros termékkeresés az ágens alapú ... - ventic https://ventic.ai/hu/faq/rag-s-vektoros-termkkeress-az-gens-alap-kereskedelemben
[10] Mikä on RAG? https://arjenai.fi/blog/mik--on-rag
[11] Oman datan ja tekoälyn yhdistäminen – RAG-mallin anatomia https://arena.jamk.fi/fi/arena-pro/oman-datan-ja-tekoalyn-yhdistaminen-rag-mallin-anatomia/
[12] RAG (Retrieval Augmented Generation) — простое и ... https://habr.com/ru/articles/779526/
[13] Mis on RAG - AppStar https://appstar.com.ru/et/glossary/rag/
[14] Mis on AI RAG? Selge ja konkreetne juhend Retrieval-Augmented ... https://sider.ai/et/blog/other/what-is-ai-rag-a-clear-no-fluff-guide-to-retrieval-augmented-generation
[15] Why vector search RAG fails (try these methods instead) https://www.youtube.com/watch?v=AwwCY4wqGyQ

---
Kuidas ehitada lihtsat RAG süsteemi

Lihtsa RAG-süsteemi jaoks piisab neljast sammust: andmete laadimine, embedding’ute loomine, vektorotsing ja vastuse genereerimine. [1][2][3][4]

### 1. Komponendid, mida vajad

- **LLM**: nt OpenAI, Ollama, vLLM vms, mis genereerib vastuse. [1][3][5]
- **Embedding mudel**: tekst → vektor (bge, OpenAI embeddings jne). [2][3]
- **Vektorhoidla**: lihtsuse mõttes kas FAISS, Chroma või isegi enda klass, mis hoiab vektoreid mälus. [1][2][6]
- **Dokumendid**: tekstifailid, PDF-id, wiki dump – midagi, mille pealt vastuseid otsida. [7][1][2]

### 2. Andmete ettevalmistus

- Loed kõik dokumendid sisse ja tükeldad need väikesteks lõikudeks (näiteks 300–800 tokenit), et otsing oleks täpsem. [1][2][4]
- Hoidmiseks teed igale tükile ID, algteksti ja meta (failinimi, sektsioon jne). [2][3][4]

Lihtne näide: üks Markdown-fail, mille jagad lõikudeks tühjade ridade või maks-pikkuse järgi. [1][4]

### 3. Embedding + vektorindeks

- Lased embedding-mudelist läbi kõik tekstilõigud ja saad igaühe kohta vektori. [2][3][8]
- Salvestad vektorid koos metaandmetega vektorindeksisse (nt FAISS index + eraldi JSON meta jaoks). [1][2][6]

Kontseptsioonina piisab isegi Python-klassist `VectorDatabase`, mis hoiab listi `{"id", "vector", "metadata"}` ja teeb kosinus-sarnasuse otsingu. [2]

### 4. Päringu käsitlemine (RAG loop)

- Kasutaja küsimus → embedding mudeli kaudu vektoriks. [2][5]
- Vektorhoidlast otsid top-k kõige sarnasemat tekstilõiku (nt k=3–5). [2][6][4]
- Paned prompti stiilis:  
  - “Kontekst:\n{top_k lõigud}\n\nKüsimus: {user_question}\nVasta ainult konteksti põhjal.” [1][3][5]
- Annad selle prompti LLM-ile ja saad vastuse, mida näitad kasutajale. [1][3][5][4]

### 5. Väga minimaalne arhitektuur

- `prepare_data.py`: loeb failid, tükeldab. [1][4]
- `create_embeddings.py`: teeb embeddingud dokulõikudele ja salvestab. [1][2][4]
- `store_faiss.py` või oma `vector_db.py`: ehitab vektorindeksi. [1][2][4]
- `generate_answer.py`: teeb query → retrieve → prompt → LLM. [1][3][5][4]

Kui tahad, võin järgmises sammus visata sulle konkreetse, võimalikult lühikese Python-näite: üks skript, mis loeb `.txt`-faili, ehitab mälus vektorindeksi (nt `sentence-transformers` + `faiss` või puhas `numpy`) ja laseb käsurealt küsida.

Citations:
[1] How to Build a RAG System Step by Step (New Guide) https://www.designveloper.com/blog/how-to-build-rag/
[2] Build A Vector Database From Scratch To Understand RAG In Depth https://www.intoai.pub/p/build-a-vector-database-from-scratch
[3] Code a simple RAG from scratch - Hugging Face https://huggingface.co/blog/ngxson/make-your-own-rag
[4] 7 Steps to Build a Simple RAG System from Scratch - KDnuggets https://www.kdnuggets.com/7-steps-to-build-a-simple-rag-system-from-scratch
[5] Build a Simple RAG Pipeline in 30 Minutes! https://www.youtube.com/watch?v=gcqp3Fbv4_o
[6] How to Use Vector Databases for RAG - LangChain Tutorials https://langchain-tutorials.com/lessons/rag-applications/lesson-12
[7] Peale põhilise toomise-liitmise põlvkonna (RAG) https://tilde.ai/et/blog/going-beyond-simple-rag/
[8] 2-Build RAG Pipeline From Scratch-Data Ingestion to Vector DB Pipeline-Part 1 https://www.youtube.com/watch?v=MykcjWPJ6T4
[9] Kokkama Ragnega https://www.kokkama.ee
[10] Kokkama - Ragne Värk (@kokkamaragnega) https://www.facebook.com/kokkamaragnega/?locale=et_EE
[11] Nii kreemine, nii lihtne, nii hea☺️ Pastaroog 15 minutiga ... https://www.facebook.com/kokkamaragnega/videos/nii-kreemine-nii-lihtne-nii-hea%EF%B8%8F-pastaroog-15-minutigasee-retsept-ei-vea-alt-kui/1255769306524762/
[12] Raglan shrnutí, líný raglán https://www.youtube.com/watch?v=3lZdEHEKTjc
[13] Good lint-free rags https://www.reddit.com/r/finishing/comments/1d4jvfc/good_lintfree_rags/
[14] Meet the RagLite, a Light You Can Roll Up, Beat Up, & Hang Up Anywhere https://nofilmschool.com/2014/05/raglite-light-you-can-roll-up-beat-up-hang-up-anywhere
[15] rag company products https://www.reddit.com/r/AutoDetailing/comments/y5gujm/rag_company_products/

---
Millised on parimad embeddingu mudelid RAG jaoks

RAG-i jaoks on praegu levinumad “parimad” embeddingu mudelid perekondadena: E5, BGE, GTE jms, kus konkreetne valik sõltub keelest, kiirusest ja riistvarast. [1][2][3][4]

### Hea vaikimisi valik (üldotstarbeline RAG)

- E5-sari: `intfloat/e5-base-instruct` või väiksem `e5-small` – hea täpsuse/kiiruse suhe, spetsiaalselt query–doc retrieval’i jaoks. [2][3][4][5]
- BGE-sari: `bge-base-en-v1.5` või uuem `bge-m3` – väga tugevad RAG benchmarkidel, hästi fine-tunitavad. [1][6][4][5]

### Kui tahad maksimaalset täpsust

- Suuremad E5 variandid: `e5-large-instruct` – kõrgem recall ja parem semantika, aga aeglasem. [2][3]
- Suured avatud mudelid: nt llama-embed-nemotron-8b, gritlm-7b – parem Top-1, sobivad kui GPU ja latentsus pole kriitiline. [2]

### Kui tähtis on kiirus / odavus

- `e5-small` – väga kiire, sobib suure indeksi ja reaalaja RAG jaoks, Top-5 recall endiselt väga hea. [2]
- Väiksemad MiniLM / GTE variandid (nt GTE-small) – kompaktne, piisav üldiseks semantilise otsingu RAG-iks. [1][4]

### Multilingual ja kommertspilved

- BGE-M3 ja multilingual-E5 variandid – tugev mitmekeelne tugi (Euroopa + Aasia keeled). [1][7]
- Pilve-API-d: OpenAI `text-embedding-3` seeria, Cohere Embed v3, Voyage-multilingual-2 – hästi optimeeritud RAG jaoks, kui vendor-lock ei sega. [1][6][5][8]

Kui ütled, mis keeled ja mis riistvaral (CPU/GPU, single-node vms) tahad jooksutada, võin soovitada 1–2 väga konkreetset mudelit ja isegi anda valmis `sentence-transformers` mudelinimed.

Citations:
[1] 5 Best Embedding Models for RAG: How to Choose the ... https://greennode.ai/blog/best-embedding-models-for-rag
[2] Benchmark of 16 Best Open Source Embedding Models for RAG https://research.aimultiple.com/open-source-embedding-models/
[3] Embedding Model | Sai's Notebook https://sai-tai.com/ai/agentic-system/embedding-model/
[4] Best Open-Source Embedding Models Benchmarked and Ranked https://supermemory.ai/blog/best-open-source-embedding-models-benchmarked-and-ranked/
[5] Choosing the Best Embedding Models for RAG and Document ... https://www.beam.cloud/blog/best-embedding-models
[6] Top Embedding Models in 2025 — The Complete Guide - Artsmart.ai https://artsmart.ai/blog/top-embedding-models-in-2025/
[7] Leading open-source embedding model https://www.reddit.com/r/LocalLLaMA/comments/1fl6hl3/leading_opensource_embedding_model/
[8] Best Embedding Models for RAG (2025) | Performance Benchmarks ... https://agentset.ai/leaderboard/embedding-models
[9] 9 Best Embedding Models for RAG to Try This Year - ZenML Blog https://www.zenml.io/blog/best-embedding-models-for-rag
[10] Open-source embedding models: which one's the best? https://www.reddit.com/r/Rag/comments/1nro65j/opensource_embedding_models_which_ones_the_best/
[11] Which embedding model should I use??? NEED HELP!!! https://www.reddit.com/r/Rag/comments/1hdd3u2/which_embedding_model_should_i_use_need_help/
[12] Top embedding models on the MTEB leaderboard - Modal https://modal.com/blog/mteb-leaderboard-article
[13] embeddings-benchmark/leaderboard: Code for the MTEB ... https://github.com/embeddings-benchmark/leaderboard
[14] MTEB Leaderboard - a Hugging Face Space by mteb https://huggingface.co/spaces/mteb/leaderboard
[15] NexGen Technologies (nexgencompany.ai) - GenAI Leaderboard https://leaderboard.nexgencompany.ai/mteb

---
Kui ütled, mis keeled ja mis riistvaral (CPU/GPU, single-node vms) tahad jooksutada, võin soovitada 1–2 väga konkreetset mudelit ja isegi anda valmis sentence-transformers mudelinimed.

Arvuti on 128gb ühine mälu (32cpu/96 gpu). keeled inglise (põhiline) ja Eesti.

Sinu raua ja keelte jaoks soovitaks kahte varianti: BGE-M3 (multilingual, SOTA-ish) ja multilingual-E5 (lihtne, väga tugev recall). [1][2][3][4][5]

### Soovitus #1: BGE-M3 (inglise + eesti, pikk kontekst)

- Mudel: `BAAI/bge-m3`. [2][3]
- Põhjused:  
  - Toetab 100+ keelt, sh Euroopa keeled; praktikas töötab hästi ka väiksemate keeltega nagu eesti. [1][4][5][10]
  - 8192 tokenit, seega sobib pikemate lõikude embeddimiseks ja long-doc RAG-iks. [2][3][11][5]
  - Hea tulemus MIRACL/MKQA multilinguaalsetel benchmarkidel. [4][5]
- sentence-transformers stiilis nimi (Hugging Face):  
  - `"BAAI/bge-m3"` – kasutad otse `sentence_transformers.SentenceTransformer("BAAI/bge-m3")`. [2][4]

### Soovitus #2: multilingual-E5 (lihtne, väga tugev recall)

- Mudel: `intfloat/multilingual-e5-base` või suurem `intfloat/multilingual-e5-large`. [7][6][8]
- Põhjused:  
  - E5-base on mitme võrdluse järgi parim üldine multilinguaalne retrieval-mudel (top-1 ja top-10 väga tugevad). [6][9]
  - Spetsiaalselt treenitud query vs document retrieval-iks (erinevad prefixid), mis sobib RAG-ile hästi. [6][8]
- sentence-transformers:  
  - `"intfloat/multilingual-e5-base"` (või `-large`) töötab otse `SentenceTransformer` klassiga. [7][6][8]

### Kuidas ma neid sinu puhul valiks

- Kui tahad ühte mudelit “kõigeks” (inglise + eesti, pikad dokumendid, võimalus hiljem mängida multi-vector/lexical-hybridiga) → **võta esmalt BGE-M3**. [2][3][4][5]
- Kui arvad, et sul on pigem klassikaline dense-retrieval RAG ja tahad robustset, hästi-dokitud lahendust, kus query/doc prefix Pattern on selge → **multilingual-E5-base** kui default, vajadusel hiljem large. [6][8][9]

Sul on GPU ja palju RAM-i, nii et mõlemad on täiesti jooksutatavad; pigem otsustad arenduskogemuse ja hilisemate feature’ite (nt multi-vector/hybrid retrieval) järgi. [2][11][5][6]

Citations:
[1] Best open source embedding models for EU languages https://www.reddit.com/r/LocalLLaMA/comments/1chqkph/best_open_source_embedding_models_for_eu_languages/
[2] BAAI/bge-m3 https://huggingface.co/BAAI/bge-m3
[3] BGE-M3 — BGE documentation https://bge-model.com/bge/bge_m3.html
[4] hffei/bge-m3-api https://github.com/hffei/bge-m3-api
[5] bge-m3 - JuheNext https://www.juhenext.com/model/bge-m3/
[6] Top 10 Multilingual Embedding Models for RAG https://research.aimultiple.com/multilingual-embedding-models/
[7] 5 Best Embedding Models for RAG: How to Choose the ... https://greennode.ai/blog/best-embedding-models-for-rag
[8] Multilingual E5 Large | Generative AI on Vertex AI https://docs.cloud.google.com/vertex-ai/generative-ai/docs/maas/e5/multilingual-e5-large
[9] What embedding models are best for multilingual ... https://zilliz.com/ai-faq/what-embedding-models-are-best-for-multilingual-applications
[10] BAAI/bge-m3 · list of languages supported https://huggingface.co/BAAI/bge-m3/discussions/29
[11] BGE m3 | Products https://docs.ionos.com/cloud/ai/ai-model-hub/models/embedding-models/bge-m3
[12] Estonia | EF English Proficiency Index https://www.ef.com/wwen/epi/regions/europe/estonia/
[13] Language proficiency level - Integratsiooni Sihtasutus https://www.integratsioon.ee/en/keeleoskustase
[14] megavn/bge-m3-embeddings · Hugging Face https://huggingface.co/megavn/bge-m3-embeddings
[15] Mike0307/multilingual-e5-language-detection - Hugging Face https://huggingface.co/Mike0307/multilingual-e5-language-detection

---
Kuidas integreerida pgvector FastAPI RAG rakendusse

Integreerimine käib kolmes kihis: pgvectori tabel + Python vektor-store + FastAPI RAG endpoint. [1][2][3][4]

## 1. Andmebaasi kiht (pgvector tabel)

PostgreSQL-s:

```sql
CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE documents (
  id        bigserial PRIMARY KEY,
  content   text NOT NULL,
  metadata  jsonb,
  embedding vector(1536) -- vasta sinu embeddingu dimensioonile
);
```

Selline skeem on tüüpiline RAG jaoks: tekst + meta + embedding. [5][1]

## 2. Python vektor-store (pgvector + asyncpg)

Näide eraldi moodulis `vector_store.py`:

```python
# vector_store.py
import asyncpg
from typing import List, Optional
import json

class VectorStore:
    def __init__(self, pool: asyncpg.Pool):
        self.pool = pool

    async def insert_document(self, content: str, embedding: List[float], metadata: Optional[dict] = None) -> int:
        emb_str = f"[{','.join(map(str, embedding))}]"
        query = """
        INSERT INTO documents (content, embedding, metadata)
        VALUES ($1, $2::vector, $3)
        RETURNING id
        """
        async with self.pool.acquire() as conn:
            row = await conn.fetchrow(query, content, emb_str, json.dumps(metadata or {}))
            return row["id"]

    async def search_similar(self, query_embedding: List[float], limit: int = 5) -> List[dict]:
        emb_str = f"[{','.join(map(str, query_embedding))}]"
        query = """
        SELECT id, content, metadata,
               1 - (embedding <=> $1::vector) AS similarity
        FROM documents
        ORDER BY embedding <=> $1::vector
        LIMIT $2
        """
        async with self.pool.acquire() as conn:
            rows = await conn.fetch(query, emb_str, limit)
            return [
                {
                    "id": r["id"],
                    "content": r["content"],
                    "metadata": r["metadata"],
                    "similarity": float(r["similarity"]),
                }
                for r in rows
            ]
```

Struktuur järgib sama mustrit, mida soovitatakse prod-integreerimisel pgvectoriga. [1][2][6]

## 3. RAG-funktsioon (retrieval + LLM)

Näide `rag_service.py` (pseudokood, pane siia oma embedding/LLM kliendid):

```python
# rag_service.py
from typing import List
from vector_store import VectorStore

vector_store: VectorStore  # injekteeritakse startupis
embed_model = ...          # sinu embedding mudel
llm_client = ...           # sinu LLM (OpenAI, Ollama, vllm, jne)

async def rag_answer(question: str) -> str:
    # 1) küsimuse embedding
    q_emb: List[float] = await embed_model.embed(question)

    # 2) vektorotsing pgvectorist
    docs = await vector_store.search_similar(q_emb, limit=5)

    context = "\n\n".join(d["content"] for d in docs)

    prompt = f"""Sa oled abivalmis assistent.

Kontekst:
{context}

Küsimus: {question}

Vasta ainult konteksti põhjal. Kui vastust ei leia, ütle, et andmetest ei piisa.
"""

    # 3) vastus LLM-ist
    answer = await llm_client.complete(prompt)
    return answer
```

Sarnane muster on kasutusel FastAPI + pgvector RAG näidistes (retriever eraldi klass, mida RAG kasutab). [4][7][8]

## 4. FastAPI integreerimine

`main.py`:

```python
# main.py
import asyncpg
from fastapi import FastAPI, Depends
from pydantic import BaseModel

from vector_store import VectorStore
from rag_service import rag_answer, vector_store as vs_ref

app = FastAPI()

class Query(BaseModel):
    question: str

class Answer(BaseModel):
    answer: str

@app.on_event("startup")
async def startup():
    pool = await asyncpg.create_pool(dsn="postgresql://user:pass@host:5432/db")
    vs_ref.__class__ = VectorStore  # või lihtsalt seti globaalne
    vs_ref.__init__(vs_ref, pool)   # lihtsuse mõttes; päriselus DI

@app.post("/query", response_model=Answer)
async def query_rag(body: Query):
    result = await rag_answer(body.question)
    return Answer(answer=result)
```

FastAPI näidetes kasutatakse sama mustrit: loe `asyncpg`/`pgvector` pool startupis, loo vektor-store ja kasuta seda RAG endpoint’is. [9][10][3]

## 5. Praktikad, millele tähelepanu pöörata

- **Async kogu teek**: `asyncpg`, embedding/LLM kliendid ja FastAPI endpoint’id. [1][6][4]
- **Tüüp `vector` vs `real[]`**: kasuta päris `vector` tüüpi ja `<=>` operaatorit (cosine/euclidean), mitte ise käsitsi JSON/array’ga mässamist. [5][1][2]
- **Filtreerimine**: lisa `metadata` JSONB ja kasuta `metadata @> '{"key":"value"}'` kui vajad RAG-is filtereid. [1][6]

Kui tahad, võin järgmise sammuna teha väga konkreetse “minimum viable” stack’i kirjelduse: `docker-compose.yml` (Postgres + FastAPI), `CREATE TABLE`, ja minimal embedding/LLM stub’idega, mille saad ise OpenAI/Ollama peale asendada.

Citations:
[1] How to Build pgvector Integration - OneUptime https://oneuptime.com/blog/post/2026-01-30-pgvector-integration/view
[2] pgvector support for Python - GitHub https://github.com/pgvector/pgvector-python
[3] Using pgvector-python in FastAPI to get most similar data https://stackoverflow.com/questions/77697282/using-pgvector-python-in-fastapi-to-get-most-similar-data
[4] Python RAG API Tutorial with LangChain & FastAPI – Complete Guide https://www.vitaliihonchar.com/insights/python-rag-api
[5] Building an AI-Powered Image Similarity Search with FastAPI ... https://blog.devgenius.io/building-an-ai-powered-image-similarity-search-with-fastapi-and-pgvector-eaee8e5c704a
[6] Asyncpg Integration | pgvector/pgvector-python | DeepWiki https://deepwiki.com/pgvector/pgvector-python/4.3-asyncpg-integration
[7] Local RAG tutorial - FastAPI & Ollama & pgvector - Reddit https://www.reddit.com/r/Rag/comments/1oavnif/local_rag_tutorial_fastapi_ollama_pgvector/
[8] Architecture and code for a Python RAG API using LangChain, FastAPI, and pgvector https://www.reddit.com/r/Python/comments/1ky5bgs/architecture_and_code_for_a_python_rag_api_using/
[9] AI-Powered Image Search with CLIP, pgvector, and Fast API https://dev.to/mattfergoda/ai-powered-image-search-with-clip-pgvector-and-fast-api-1f1d
[10] PGVector와 Python FastAPI를 연동하여 벡터 데이터 저장 및 유사도 ... https://lsjsj92.tistory.com/677
[11] Local RAG tutorial - FastAPI & Ollama & pgvector : r/PostgreSQL https://www.reddit.com/r/PostgreSQL/comments/1oavhi4/local_rag_tutorial_fastapi_ollama_pgvector/
[12] alexandrughinea/python-fastapi-postgres-vector-scraper https://github.com/alexandrughinea/python-fastapi-postgres-vector-scraper
[13] Local RAG tutorial - FastAPI & Ollama & pgvector https://www.reddit.com/r/ollama/comments/1obn0nj/local_rag_tutorial_fastapi_ollama_pgvector/
[14] Deep Dive with Postgres PGVector, LlamaIndex, FastAPI ... https://www.linkedin.com/pulse/advanced-guarded-rag-deep-dive-postgres-pgvector-fastapi-zahir-shaikh-bcnff
[15] Build an Optimized RAG System with Reranking & Recall/MRR Evaluation | PgVector, LangSmith, FastAPI https://www.youtube.com/watch?v=OeFlBSqasqU
