शुरुआत

गाइड: एम्बेडिंग के साथ RAG

दस्तावेज़ों को चंक में बाँटें, एम्बेड करें, कोसाइन समानता से खोजें, रीरैंक करें और उद्धरणों (citations) के साथ उत्तर दें, पूरे कोड के साथ।

रिट्रीवल-ऑगमेंटेड जनरेशन (RAG) आपके अपने दस्तावेज़ों से सवालों के जवाब देता है। आप दस्तावेज़ों को चंक में बाँटते हैं, हर चंक को एक बार एम्बेड करते हैं, और सवाल आने पर सवाल को एम्बेड करके सबसे नज़दीकी चंक ढूँढते हैं, चाहें तो उन्हें रीरैंक करते हैं, और सबसे अच्छे चंक एक चैट मॉडल को इस निर्देश के साथ भेजते हैं कि वह उनका हवाला दे।

नीचे सब कुछ बेस URL https://api14.com/api/v1, आपकी sk-api14-... कुंजी और आधिकारिक openai पैकेज का उपयोग करता है। लागत आपके प्रीपेड USD बैलेंस से कटती है और हर प्रतिक्रिया में usage.cost में लौटाई जाती है।

import os
from openai import OpenAI

client = OpenAI(base_url="https://api14.com/api/v1", api_key=os.environ["API14_API_KEY"])
EMBED_MODEL = "openai/text-embedding-3-small"
CHAT_MODEL = "openai/gpt-5-mini"

1. दस्तावेज़ों को चंक में बाँटें

चंक इतने छोटे हों कि विशिष्ट रहें और इतने बड़े कि अपने आप में अर्थपूर्ण हों। शुरुआत के लिए 500-1,000 अक्षर, कुछ ओवरलैप के साथ, पैराग्राफ़ की सीमाओं पर बाँटना अच्छा रहता है:

def chunk(text, size=800, overlap=150):
    paragraphs = [p.strip() for p in text.split("\n\n") if p.strip()]
    chunks, current = [], ""
    for p in paragraphs:
        if current and len(current) + len(p) > size:
            chunks.append(current)
            current = current[-overlap:]  # संदर्भ को अगले चंक में ले जाएँ
        current = f"{current}\n\n{p}".strip()
    if current:
        chunks.append(current)
    return chunks

docs = {"handbook.md": open("handbook.md").read(), "faq.md": open("faq.md").read()}
chunks = [{"source": name, "text": c} for name, text in docs.items() for c in chunk(text)]

हर चंक के साथ उसका स्रोत (फ़ाइल नाम, URL, पेज नंबर) रखें, उद्धरणों के लिए यह चाहिए।

2. POST /embeddings से एम्बेड करें

एक अनुरोध में कई चंक भेजें। 100 इनपुट वाला एक अनुरोध आपकी रेट लिमिट में एक अनुरोध गिना जाता है:

def embed(texts):
    vectors = []
    for i in range(0, len(texts), 100):
        r = client.embeddings.create(model=EMBED_MODEL, input=texts[i:i + 100])
        vectors += [d.embedding for d in sorted(r.data, key=lambda d: d.index)]
    return vectors

for c, v in zip(chunks, embed([c["text"] for c in chunks])):
    c["vector"] = v

वेक्टर और मॉडल id को साथ में सहेजें। अलग-अलग मॉडल के वेक्टर तुलनीय नहीं होते, इसलिए EMBED_MODEL बदलने पर पूरा कॉर्पस दोबारा एम्बेड करना होगा। देखें एम्बेडिंग।

3. कोसाइन समानता से खोजें

कुछ हज़ार चंक के लिए मेमोरी में लीनियर स्कैन पर्याप्त तेज़ है। उससे अधिक होने पर वेक्टर को वेक्टर डेटाबेस या pgvector वाली Postgres टेबल में रखें।

import math

def cosine(a, b):
    dot = sum(x * y for x, y in zip(a, b))
    return dot / (math.sqrt(sum(x * x for x in a)) * math.sqrt(sum(y * y for y in b)))

def search(question, k=20):
    q = embed([question])[0]
    return sorted(chunks, key=lambda c: cosine(q, c["vector"]), reverse=True)[:k]

4. POST /rerank से रीरैंक करें

एम्बेडिंग खोज रिकॉल में अच्छी है लेकिन क्रम तय करने में मोटी। रीरैंकर सवाल और हर उम्मीदवार को साथ पढ़कर प्रासंगिकता का ज़्यादा सटीक स्कोर देता है। 20-100 उम्मीदवार निकालें, रीरैंक करें, और शीर्ष 3-8 रखें। OpenAI SDK में rerank मेथड नहीं है, इसलिए इसे HTTP से कॉल करें (httpx openai के साथ इंस्टॉल होता है):

import httpx

def rerank(question, candidates, top_n=5):
    r = httpx.post(
        "https://api14.com/api/v1/rerank",
        headers={"Authorization": f"Bearer {os.environ['API14_API_KEY']}"},
        json={
            "model": "cohere/rerank-v3.5",
            "query": question,
            "documents": [c["text"] for c in candidates],
            "top_n": top_n,
        },
        timeout=30,
    )
    r.raise_for_status()
    return [candidates[x["index"]] for x in r.json()["results"]]

index आपके भेजे documents ऐरे की स्थिति बताता है। देखें रीरैंक।

5. उद्धरणों के साथ उत्तर दें

प्रॉम्प्ट में चंक को क्रमांकित करें और मॉडल से उन्हीं क्रमांकों का हवाला देने को कहें। उसे बताएँ कि संदर्भ में उत्तर न हो तो वैसा कह दे:

def answer(question):
    context = rerank(question, search(question))
    sources = "\n\n".join(f"[{i + 1}] ({c['source']})\n{c['text']}" for i, c in enumerate(context))
    r = client.chat.completions.create(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": (
                "Answer only from the numbered sources. Cite them like [1] or [2][3] after each claim. "
                "If the sources do not contain the answer, say you don't know."
            )},
            {"role": "user", "content": f"Sources:\n\n{sources}\n\nQuestion: {question}"},
        ],
    )
    return r.choices[0].message.content, context, r.usage.cost

यदि आपके ऐप को उद्धरण डेटा के रूप में चाहिए, तो ब्रैकेट पार्स करने के बजाय { "answer": string, "citations": integer[] } जैसे schema के साथ स्ट्रक्चर्ड आउटपुट इस्तेमाल करें।

Node में वही पाइपलाइन

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api14.com/api/v1", apiKey: process.env.API14_API_KEY });

const embed = async (input) =>
  (await client.embeddings.create({ model: "openai/text-embedding-3-small", input })).data.map((d) => d.embedding);

const cosine = (a, b) => {
  let dot = 0, na = 0, nb = 0;
  for (let i = 0; i < a.length; i++) { dot += a[i] * b[i]; na += a[i] ** 2; nb += b[i] ** 2; }
  return dot / Math.sqrt(na * nb);
};

async function answer(question, chunks /* [{ source, text, vector }] */) {
  const [q] = await embed([question]);
  const candidates = chunks.map((c) => ({ ...c, score: cosine(q, c.vector) }))
    .sort((a, b) => b.score - a.score).slice(0, 20);

  const ranked = await client.post("/rerank", {
    body: { model: "cohere/rerank-v3.5", query: question, documents: candidates.map((c) => c.text), top_n: 5 },
  });
  const context = ranked.results.map((r) => candidates[r.index]);

  const sources = context.map((c, i) => `[${i + 1}] (${c.source})\n${c.text}`).join("\n\n");
  const res = await client.chat.completions.create({
    model: "openai/gpt-5-mini",
    messages: [
      { role: "system", content: "Answer only from the numbered sources and cite them like [1]. If they do not contain the answer, say so." },
      { role: "user", content: `Sources:\n\n${sources}\n\nQuestion: ${question}` },
    ],
  });
  return res.choices[0].message.content;
}

लागत का अनुमान

RAG सिस्टम में तीन लागत मदें होती हैं, सब USD में और सब usage.cost में रिपोर्ट होती हैं:

चरण	कब	बिलिंग इकाई
कॉर्पस की एम्बेडिंग	एक बार, और दस्तावेज़ बदलने पर फिर से	इनपुट टोकन
सवाल की एम्बेडिंग + रीरैंक	हर सवाल पर	इनपुट टोकन / सर्च
चैट उत्तर	हर सवाल पर	इनपुट और आउटपुट टोकन

चलाने से पहले अनुमान लगाने के लिए GET /models/{id} से मॉडल की कीमतें लें (pricing.prompt और pricing.completion प्रति टोकन USD हैं) और अंग्रेज़ी टेक्स्ट के लिए लगभग 4 अक्षर प्रति टोकन मानें:

import httpx

def price(model_id):
    return httpx.get(f"https://api14.com/api/v1/models/{model_id}").json()["pricing"]

corpus_tokens = sum(len(c["text"]) for c in chunks) / 4
print("One-off embedding:", corpus_tokens * float(price(EMBED_MODEL)["prompt"]), "USD")

p = price(CHAT_MODEL)
prompt_tokens, answer_tokens = 5 * 800 / 4 + 200, 300  # 5 चंक + निर्देश, छोटा उत्तर
print("Per answer:", prompt_tokens * float(p["prompt"]) + answer_tokens * float(p["completion"]), "USD")

चैट कॉल आमतौर पर सबसे बड़ी मद होती है। इसे घटाने के लिए कम और छोटे चंक भेजें (रीरैंकिंग इसे सुरक्षित बनाती है), सिस्टम प्रॉम्प्ट को शुरुआत में स्थिर रखें ताकि प्रॉम्प्ट कैशिंग लागू हो सके, और max_tokens सेट करें। बाद में असली लागत usage.cost या जनरेशन लुकअप से जाँचें।