ಆಧುನಿಕ ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳೊಂದಿಗೆ RAG (ಮರುಪಡೆಯುವಿಕೆ-ವರ್ಧಿತ ಜನರೇಷನ್) ಸಂಯೋಜಿಸುವುದು: ಪ್ರಾಯೋಗಿಕ ಮಾರ್ಗದರ್ಶಿ

ಪರಿಚಯ

ಇತ್ತೀಚಿನ ವರ್ಷಗಳಲ್ಲಿ, ನ್ಯಾಚುರಲ್ ಲ್ಯಾಂಗ್ವೇಜ್ ಪ್ರೊಸೆಸಿಂಗ್ (ಎನ್‌ಎಲ್‌ಪಿ) ಕ್ಷೇತ್ರವು ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳ (ಎಲ್‌ಎಲ್‌ಎಂ) ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಗಮನಾರ್ಹ ಏರಿಕೆಗೆ ಸಾಕ್ಷಿಯಾಗಿದೆ ಮತ್ತು ವಿವಿಧ ಡೊಮೇನ್‌ಗಳಲ್ಲಿ ಅವುಗಳ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು. ಆದಾಗ್ಯೂ, LLM ಗಳ ಒಂದು ಪ್ರಮುಖ ಮಿತಿಯೆಂದರೆ ತಮ್ಮ ಪ್ರತಿಕ್ರಿಯೆಗಳಲ್ಲಿ ಬಾಹ್ಯ ಜ್ಞಾನವನ್ನು ಹಿಂಪಡೆಯಲು ಮತ್ತು ಸಂಯೋಜಿಸಲು ಅಸಮರ್ಥತೆಯಾಗಿದೆ. ಇಲ್ಲಿ ರಿಟ್ರೈವಲ್-ಆಗ್ಮೆಂಟೆಡ್ ಜನರೇಷನ್ (RAG) ತಂತ್ರಗಳು ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತವೆ. ಈ ಲೇಖನದಲ್ಲಿ, ತಡೆರಹಿತ ಡೇಟಾ ಮರುಪಡೆಯುವಿಕೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗಾಗಿ LangChain ನೊಂದಿಗೆ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಸೇರಿದಂತೆ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ LLM ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೆಚ್ಚಿಸಲು FastAPI ಮತ್ತು ಜಾಂಗೊವನ್ನು ಬಳಸಿಕೊಂಡು RAG ತಂತ್ರಗಳ ಅನುಷ್ಠಾನವನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.

RAG ಎಂದರೇನು?

RAG ಎನ್ನುವುದು ಹೆಚ್ಚು ನಿಖರವಾದ ಮತ್ತು ತಿಳಿವಳಿಕೆ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಮರುಪಡೆಯುವಿಕೆ ಮತ್ತು ಜನರೇಷನ್ ಮಾದರಿಗಳ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಸಂಯೋಜಿಸುವ ತಂತ್ರವಾಗಿದೆ. RAG ನ ಹಿಂದಿನ ಮೂಲ ಕಲ್ಪನೆಯು ಮೊದಲು ಜ್ಞಾನದ ಮೂಲ ಅಥವಾ ಡೇಟಾಬೇಸ್‌ನಿಂದ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ಹಿಂಪಡೆಯುವುದು ಮತ್ತು ನಂತರ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ರಚಿಸಲು ಈ ಮಾಹಿತಿಯನ್ನು ಬಳಸುವುದು. ಈ ವಿಧಾನವು LLM ಗಳಿಗೆ ಬಾಹ್ಯ ಜ್ಞಾನವನ್ನು ಹತೋಟಿಗೆ ತರಲು ಮತ್ತು ಹೆಚ್ಚು ನಿಖರವಾದ ಮತ್ತು ತಿಳಿವಳಿಕೆ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಒದಗಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.

** FastAPI ಮತ್ತು ಜಾಂಗೊ ಜೊತೆಗೆ RAG ಅನ್ನು ಏಕೆ ಬಳಸಬೇಕು?**

FastAPI ಮತ್ತು ಜಾಂಗೊ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಬಳಸಲಾಗುವ ಎರಡು ಜನಪ್ರಿಯ ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳಾಗಿವೆ. ಅವರು ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ದೃಢವಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಮೂಲಸೌಕರ್ಯವನ್ನು ಒದಗಿಸುತ್ತಾರೆ ಮತ್ತು LLM ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೆಚ್ಚಿಸಲು RAG ತಂತ್ರಗಳೊಂದಿಗೆ ಸುಲಭವಾಗಿ ಸಂಯೋಜಿಸಬಹುದು. FastAPI ಆಧುನಿಕ ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದ್ದು ಅದು ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ವೇಗವಾದ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಆದರೆ ಜಾಂಗೊ ಒಂದು ಉನ್ನತ ಮಟ್ಟದ ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದ್ದು ಅದು ದೃಢವಾದ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಆರ್ಕಿಟೆಕ್ಚರ್, ಟೆಂಪ್ಲೇಟ್‌ಗಳು ಮತ್ತು API ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

FastAPI ನೊಂದಿಗೆ RAG ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತಿದೆ

RAG ತಂತ್ರಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು FastAPI ಸರಳ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. RAG ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು FastAPI ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುವ ಉದಾಹರಣೆ ಕೋಡ್ ಬ್ಲಾಕ್ ಇಲ್ಲಿದೆ:

``ಹೆಬ್ಬಾವು ಫಾಸ್ಟಾಪಿ ಆಮದು FastAPI ನಿಂದ Langchain ಆಮದು LLMCchain ನಿಂದ langchain.chains.openai ನಿಂದ OpenAIApi ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ

ಅಪ್ಲಿಕೇಶನ್ = FastAPI()

@app.get("/rag") async def rag(ಪ್ರಶ್ನೆ: str):

llm_chain = LLMCchain(
    llm=OpenAIApi(),
    ಮರುಪಡೆಯುವಿಕೆ=LangChainRetrieval(
        ಸೂಚ್ಯಂಕ=LangChainIndex(
            ಹೆಸರು="ನನ್ನ_ಸೂಚ್ಯಂಕ",
            ದಾಖಲೆಗಳು=["doc1", "doc2", "doc3"]
        )
    )
)

# LLM ಸರಪಳಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ರಚಿಸಿ
ಪ್ರತಿಕ್ರಿಯೆ = llm_chain.run(ಪ್ರಶ್ನೆ)

ಹಿಂತಿರುಗಿ {"ಪ್ರತಿಕ್ರಿಯೆ": ಪ್ರತಿಕ್ರಿಯೆ}

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು LangChain ನಿಂದ `LLMchain` ವರ್ಗವನ್ನು ಬಳಸಿಕೊಂಡು LLM ಸರಪಳಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. ನಂತರ ನಾವು `LangChainRetrieval` ವರ್ಗವನ್ನು ಬಳಸಿಕೊಂಡು ಮರುಪಡೆಯುವಿಕೆ ಘಟಕವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ, ಇದನ್ನು ಜ್ಞಾನದ ಮೂಲ ಅಥವಾ ಡೇಟಾಬೇಸ್‌ನಿಂದ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ಹಿಂಪಡೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ. ಅಂತಿಮವಾಗಿ, LLM ಸರಪಳಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ರಚಿಸಲು ನಾವು `ರನ್` ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ.

** ಜಾಂಗೊದೊಂದಿಗೆ RAG ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು**


ಜಾಂಗೊ ಉನ್ನತ ಮಟ್ಟದ ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ ಅದನ್ನು RAG ತಂತ್ರಗಳೊಂದಿಗೆ ಸುಲಭವಾಗಿ ಸಂಯೋಜಿಸಬಹುದು. RAG ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಜಾಂಗೊವನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುವ ಉದಾಹರಣೆ ಕೋಡ್ ಬ್ಲಾಕ್ ಇಲ್ಲಿದೆ:

``ಹೆಬ್ಬಾವು
django.http ಇಂಪೋರ್ಟ್ JsonResponse
Langchain ಆಮದು LLMCchain ನಿಂದ
langchain.chains.openai ನಿಂದ OpenAIApi ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ

ಡೆಫ್ ರಾಗ್ (ವಿನಂತಿ):
    # LLM ಸರಪಳಿಯನ್ನು ವಿವರಿಸಿ
    llm_chain = LLMCchain(
        llm=OpenAIApi(),
        ಮರುಪಡೆಯುವಿಕೆ=LangChainRetrieval(
            ಸೂಚ್ಯಂಕ=LangChainIndex(
                ಹೆಸರು="ನನ್ನ_ಸೂಚ್ಯಂಕ",
                ದಾಖಲೆಗಳು=["doc1", "doc2", "doc3"]
            )
        )
    )

    # LLM ಸರಪಳಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ರಚಿಸಿ
    ಪ್ರತಿಕ್ರಿಯೆ = llm_chain.run(request.GET.get("query"))

    JsonResponse ಹಿಂತಿರುಗಿ({"response": response})

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಪ್ರಶ್ನೆಯನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು LLM ಸರಪಳಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಉತ್ಪಾದಿಸುವ ವೀಕ್ಷಣೆ ಕಾರ್ಯ ರಾಗ್ ಅನ್ನು ನಾವು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ.

ಲ್ಯಾಂಗ್‌ಚೈನ್‌ನೊಂದಿಗೆ ಆರ್‌ಕೆಸ್ಟ್ರೇಟಿಂಗ್ RAG

RAG ತಂತ್ರಗಳನ್ನು ಸಂಘಟಿಸಲು LangChain ಸರಳ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. RAG ಅನ್ನು ಆರ್ಕೆಸ್ಟ್ರೇಟ್ ಮಾಡಲು LangChain ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುವ ಉದಾಹರಣೆ ಕೋಡ್ ಬ್ಲಾಕ್ ಇಲ್ಲಿದೆ:

``ಹೆಬ್ಬಾವು Langchain ಆಮದು LLMCchain ನಿಂದ langchain.chains.openai ನಿಂದ OpenAIApi ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ

LLM ಸರಪಳಿಯನ್ನು ವಿವರಿಸಿ

llm_chain = LLMCchain( llm=OpenAIApi(), ಮರುಪಡೆಯುವಿಕೆ=LangChainRetrieval( ಸೂಚ್ಯಂಕ=LangChainIndex( ಹೆಸರು="ನನ್ನ_ಸೂಚ್ಯಂಕ", ದಾಖಲೆಗಳು=["doc1", "doc2", "doc3"] ) ) )

LLM ಸರಪಳಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ರಚಿಸಿ

ಪ್ರತಿಕ್ರಿಯೆ = llm_chain.run ("RAG ಎಂದರೇನು?")

ಮುದ್ರಣ (ಪ್ರತಿಕ್ರಿಯೆ)

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು LangChain ನಿಂದ `LLMchain` ವರ್ಗವನ್ನು ಬಳಸಿಕೊಂಡು LLM ಸರಪಳಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. ನಂತರ ನಾವು LLM ಸರಪಳಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ರಚಿಸಲು `ರನ್` ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ.

**ಟಾಪ್ 5-10 ಹೆಚ್ಚು ಬಳಸಿದ ಆಜ್ಞೆಗಳು/ತುಣುಕುಗಳು**


FastAPI ಮತ್ತು ಜಾಂಗೊದೊಂದಿಗೆ RAG ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಟಾಪ್ 5-10 ಕಮಾಂಡ್‌ಗಳು/ತುಣುಕುಗಳು ಇಲ್ಲಿವೆ:

1. `Langchain ಆಮದು LLMCchain ನಿಂದ`: LangChain ನಿಂದ `LLMChain` ವರ್ಗವನ್ನು ಆಮದು ಮಾಡಿ.
2. `llm_chain = LLMCchain(llm=OpenAIApi(), retrieval=LangChainRetrieval(ಸೂಚ್ಯಂಕ=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"])))`: LLMha ಅನ್ನು ಬಳಸಿಕೊಂಡು `.LLMha' ವರ್ಗವನ್ನು ವಿವರಿಸಿ
3. `response = llm_chain.run(query)`: LLM ಸರಪಳಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ರಚಿಸಿ.
4. `Fastapi ಆಮದು FastAPI ನಿಂದ`: FastAPI ನಿಂದ `FastAPI` ವರ್ಗವನ್ನು ಆಮದು ಮಾಡಿ.
5. `ಅಪ್ಲಿಕೇಶನ್ = FastAPI()`: FastAPI ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ವಿವರಿಸಿ.
6. `@app.get("/rag")`: RAG ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಾಗಿ ಮಾರ್ಗವನ್ನು ವಿವರಿಸಿ.
7. `llm_chain = LLMCchain(llm=OpenAIApi(), retrieval=LangChainRetrieval(ಸೂಚ್ಯಂಕ=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"])))`: LLMha ಅನ್ನು ಬಳಸಿಕೊಂಡು LLMha ವರ್ಗವನ್ನು ವಿವರಿಸಿ.
8. `response = llm_chain.run(query)`: LLM ಸರಪಳಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ರಚಿಸಿ.
9. `django.http ಇಂಪೋರ್ಟ್ JsonResponse`: ಜಾಂಗೊದಿಂದ `JsonResponse` ವರ್ಗವನ್ನು ಆಮದು ಮಾಡಿ.
10. `ರಿಟರ್ನ್ JsonResponse({"response": response})`: ರಚಿತವಾದ ಪ್ರತಿಕ್ರಿಯೆಯೊಂದಿಗೆ JSON ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂತಿರುಗಿ.

**ದೃಶ್ಯೀಕರಣ**


Chart.js ಅನ್ನು ಬಳಸಿಕೊಂಡು RAG ಪೈಪ್‌ಲೈನ್‌ನ ದೃಶ್ಯೀಕರಣ ಇಲ್ಲಿದೆ:

```json
{
  "ಟೈಪ್": "ಅಡ್ಡಪಟ್ಟಿ",
  "ಡೇಟಾ": {
    "ಲೇಬಲ್‌ಗಳು": ["ಮರುಪಡೆಯುವಿಕೆ", "ಜನರೇಶನ್", "ನಂತರದ ಪ್ರಕ್ರಿಯೆ"],
    "ಡೇಟಾಸೆಟ್‌ಗಳು": [
      {
        "ಲೇಬಲ್": "RAG ಪೈಪ್‌ಲೈನ್",
        "ಡೇಟಾ": [10, 20, 30],
        "ಹಿನ್ನೆಲೆ ಬಣ್ಣ": [
          "rgba(255, 99, 132, 0.2)",
          "rgba(54, 162, 235, 0.2)",
          "rgba(255, 206, 86, 0.2)"
        ],
        "ಬಾರ್ಡರ್ ಕಲರ್": [
          "rgba(255, 99, 132, 1)",
          "rgba(54, 162, 235, 1)",
          "rgba(255, 206, 86, 1)"
        ],
        "ಬಾರ್ಡರ್ ಅಗಲ": 1
      }
    ]
  },
  "ಆಯ್ಕೆಗಳು": {
    "ಶೀರ್ಷಿಕೆ": {
      "ಪ್ರದರ್ಶನ": ನಿಜ,
      "ಪಠ್ಯ": "RAG ಪೈಪ್‌ಲೈನ್"
    },
    "ಮಾಪಕಗಳು": {
      "yAxes": [
        {
          "ಉಣ್ಣಿ": {
            "beginAtZero": ನಿಜ
          }
        }
      ]
    }
  }
}

ಈ ದೃಶ್ಯೀಕರಣವು ಮೂರು ಹಂತಗಳೊಂದಿಗೆ RAG ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ತೋರಿಸುತ್ತದೆ: ಮರುಪಡೆಯುವಿಕೆ, ಉತ್ಪಾದನೆ ಮತ್ತು ನಂತರದ ಪ್ರಕ್ರಿಯೆ.

** ತೀರ್ಮಾನ **

ಈ ಲೇಖನದಲ್ಲಿ, ತಡೆರಹಿತ ಡೇಟಾ ಮರುಪಡೆಯುವಿಕೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗಾಗಿ LangChain ನೊಂದಿಗೆ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಸೇರಿದಂತೆ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ LLM ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೆಚ್ಚಿಸಲು FastAPI ಮತ್ತು ಜಾಂಗೊವನ್ನು ಬಳಸಿಕೊಂಡು RAG ತಂತ್ರಗಳ ಅನುಷ್ಠಾನವನ್ನು ನಾವು ಅನ್ವೇಷಿಸಿದ್ದೇವೆ. ಕೋಡ್ ಉದಾಹರಣೆಗಳು ಮತ್ತು RAG ಪೈಪ್‌ಲೈನ್‌ನ ದೃಶ್ಯೀಕರಣವನ್ನು ಒಳಗೊಂಡಂತೆ FastAPI ಮತ್ತು ಜಾಂಗೊದೊಂದಿಗೆ RAG ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಾವು ಪ್ರಾಯೋಗಿಕ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಸಹ ಒದಗಿಸಿದ್ದೇವೆ. ತಮ್ಮ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ RAG ತಂತ್ರಗಳನ್ನು ಅಳವಡಿಸಲು ಬಯಸುವ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಈ ಲೇಖನವು ಉಪಯುಕ್ತ ಸಂಪನ್ಮೂಲವನ್ನು ಒದಗಿಸಿದೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ.