ਆਧੁਨਿਕ ਵੈੱਬ ਫਰੇਮਵਰਕ ਦੇ ਨਾਲ ਆਰਏਜੀ (ਰੀਟ੍ਰੀਵਲ-ਔਗਮੈਂਟਡ ਜਨਰੇਸ਼ਨ) ਨੂੰ ਏਕੀਕ੍ਰਿਤ ਕਰਨਾ: ਇੱਕ ਪ੍ਰੈਕਟੀਕਲ ਗਾਈਡ

ਜਾਣ-ਪਛਾਣ

ਹਾਲ ਹੀ ਦੇ ਸਾਲਾਂ ਵਿੱਚ, ਨੈਚੁਰਲ ਲੈਂਗੂਏਜ ਪ੍ਰੋਸੈਸਿੰਗ (NLP) ਦੇ ਖੇਤਰ ਵਿੱਚ ਵੱਡੇ ਭਾਸ਼ਾ ਮਾਡਲਾਂ (LLMs) ਅਤੇ ਵੱਖ-ਵੱਖ ਡੋਮੇਨਾਂ ਵਿੱਚ ਉਹਨਾਂ ਦੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਵਿਕਾਸ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਵਾਧਾ ਹੋਇਆ ਹੈ। ਹਾਲਾਂਕਿ, LLMs ਦੀਆਂ ਪ੍ਰਮੁੱਖ ਸੀਮਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਉਹਨਾਂ ਦੇ ਜਵਾਬਾਂ ਵਿੱਚ ਬਾਹਰੀ ਗਿਆਨ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਸ਼ਾਮਲ ਕਰਨ ਵਿੱਚ ਅਸਮਰੱਥਾ ਹੈ। ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਰੀਟ੍ਰੀਵਲ-ਔਗਮੈਂਟੇਡ ਜਨਰੇਸ਼ਨ (RAG) ਤਕਨੀਕਾਂ ਲਾਗੂ ਹੁੰਦੀਆਂ ਹਨ। ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ LLM ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਵਧਾਉਣ ਲਈ FastAPI ਅਤੇ Django ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ RAG ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਸਹਿਜ ਡਾਟਾ ਪ੍ਰਾਪਤੀ ਅਤੇ ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ LangChain ਨਾਲ ਆਰਕੈਸਟਰੇਸ਼ਨ ਸ਼ਾਮਲ ਹੈ।

RAG ਕੀ ਹੈ?

RAG ਇੱਕ ਤਕਨੀਕ ਹੈ ਜੋ ਵਧੇਰੇ ਸਟੀਕ ਅਤੇ ਜਾਣਕਾਰੀ ਭਰਪੂਰ ਜਵਾਬ ਪੈਦਾ ਕਰਨ ਲਈ ਮੁੜ ਪ੍ਰਾਪਤੀ ਅਤੇ ਜਨਰੇਸ਼ਨ ਮਾਡਲਾਂ ਦੀਆਂ ਸ਼ਕਤੀਆਂ ਨੂੰ ਜੋੜਦੀ ਹੈ। RAG ਦੇ ਪਿੱਛੇ ਮੂਲ ਵਿਚਾਰ ਪਹਿਲਾਂ ਕਿਸੇ ਗਿਆਨ ਅਧਾਰ ਜਾਂ ਡੇਟਾਬੇਸ ਤੋਂ ਸੰਬੰਧਿਤ ਜਾਣਕਾਰੀ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ, ਅਤੇ ਫਿਰ ਜਵਾਬ ਬਣਾਉਣ ਲਈ ਇਸ ਜਾਣਕਾਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ। ਇਹ ਪਹੁੰਚ LLM ਨੂੰ ਬਾਹਰੀ ਗਿਆਨ ਦਾ ਲਾਭ ਉਠਾਉਣ ਅਤੇ ਵਧੇਰੇ ਸਹੀ ਅਤੇ ਜਾਣਕਾਰੀ ਭਰਪੂਰ ਜਵਾਬ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।

ਫਾਸਟਏਪੀਆਈ ਅਤੇ ਜੈਂਗੋ ਨਾਲ RAG ਦੀ ਵਰਤੋਂ ਕਿਉਂ ਕਰੀਏ?

FastAPI ਅਤੇ Django ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਲਈ ਵਰਤੇ ਜਾਣ ਵਾਲੇ ਦੋ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਵੈੱਬ ਫਰੇਮਵਰਕ ਹਨ। ਉਹ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਣਾਉਣ ਲਈ ਇੱਕ ਮਜ਼ਬੂਤ ​​ਅਤੇ ਸਕੇਲੇਬਲ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਅਤੇ LLM ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਵਧਾਉਣ ਲਈ RAG ਤਕਨੀਕਾਂ ਨਾਲ ਆਸਾਨੀ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। FastAPI ਇੱਕ ਆਧੁਨਿਕ ਵੈੱਬ ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਇੱਕ ਤੇਜ਼ ਅਤੇ ਕੁਸ਼ਲ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜਦੋਂ ਕਿ Django ਇੱਕ ਉੱਚ-ਪੱਧਰੀ ਵੈੱਬ ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਮਜ਼ਬੂਤ ​​ਵੈਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਣਾਉਣ ਲਈ ਇੱਕ ਆਰਕੀਟੈਕਚਰ, ਟੈਂਪਲੇਟ ਅਤੇ API ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਫਾਸਟਏਪੀਆਈ ਨਾਲ RAG ਨੂੰ ਲਾਗੂ ਕਰਨਾ

FastAPI RAG ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦਾ ਇੱਕ ਸਧਾਰਨ ਅਤੇ ਕੁਸ਼ਲ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਕੋਡ ਬਲਾਕ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ RAG ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ FastAPI ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ:

``ਅਜਗਰ fastapi ਤੋਂ FastAPI ਆਯਾਤ ਕਰੋ ਲੈਂਗਚੈਨ ਆਯਾਤ ਐਲਐਲਐਮਚੇਨ ਤੋਂ langchain.chains.openai ਤੋਂ OpenAIApi ਆਯਾਤ ਕਰੋ

ਐਪ = FastAPI()

@app.get("/rag") async def rag(query: str):

llm_chain = LLMCਚੇਨ (
    llm=OpenAIApi(),
    retrieval=LangChainRetrieval(
        index=LangChainIndex(
            name="my_index",
            ਦਸਤਾਵੇਜ਼=["doc1", "doc2", "doc3"]
        )
    )
)

# LLM ਚੇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਜਵਾਬ ਤਿਆਰ ਕਰੋ
ਜਵਾਬ = llm_chain.run (ਪੁੱਛਗਿੱਛ)

ਵਾਪਸੀ {"response": ਜਵਾਬ}

``

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ LangChain ਤੋਂ LLMChain ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ LLM ਚੇਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ। ਅਸੀਂ ਫਿਰ 'LangChainRetrieval' ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਪੁਨਰ ਪ੍ਰਾਪਤੀ ਹਿੱਸੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ, ਜੋ ਕਿ ਕਿਸੇ ਗਿਆਨ ਅਧਾਰ ਜਾਂ ਡੇਟਾਬੇਸ ਤੋਂ ਸੰਬੰਧਿਤ ਜਾਣਕਾਰੀ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਅੰਤ ਵਿੱਚ, ਅਸੀਂ LLM ਚੇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਜਵਾਬ ਪੈਦਾ ਕਰਨ ਲਈ ਰਨ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।

ਜੈਂਗੋ ਨਾਲ RAG ਨੂੰ ਲਾਗੂ ਕਰਨਾ

Django ਇੱਕ ਉੱਚ-ਪੱਧਰੀ ਵੈੱਬ ਫਰੇਮਵਰਕ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜਿਸਨੂੰ ਆਸਾਨੀ ਨਾਲ RAG ਤਕਨੀਕਾਂ ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਕੋਡ ਬਲਾਕ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ RAG ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ Django ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ:

``ਅਜਗਰ django.http ਤੋਂ JsonResponse ਆਯਾਤ ਕਰੋ ਲੈਂਗਚੈਨ ਆਯਾਤ ਐਲਐਲਐਮਚੇਨ ਤੋਂ langchain.chains.openai ਤੋਂ OpenAIApi ਆਯਾਤ ਕਰੋ

def ਰਾਗ (ਬੇਨਤੀ): # LLM ਚੇਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ llm_chain = LLMCਚੇਨ ( llm=OpenAIApi(), retrieval=LangChainRetrieval( index=LangChainIndex( name="my_index", ਦਸਤਾਵੇਜ਼=["doc1", "doc2", "doc3"] ) ) )

# LLM ਚੇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਜਵਾਬ ਤਿਆਰ ਕਰੋ
ਜਵਾਬ = llm_chain.run(request.GET.get("query"))

JsonResponse ਵਾਪਸ ਕਰੋ ({"response": response})

``

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਵਿਊ ਫੰਕਸ਼ਨ rag ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ ਜੋ ਇੱਕ ਪੁੱਛਗਿੱਛ ਨੂੰ ਇਨਪੁਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ ਅਤੇ LLM ਚੇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਜਵਾਬ ਤਿਆਰ ਕਰਦਾ ਹੈ।

LangChain ਨਾਲ ਆਰਕੈਸਟਰੇਟ ਕਰਨਾ

LangChain RAG ਤਕਨੀਕਾਂ ਨੂੰ ਆਰਕੈਸਟਰੇਟ ਕਰਨ ਦਾ ਇੱਕ ਸਧਾਰਨ ਅਤੇ ਕੁਸ਼ਲ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਕੋਡ ਬਲਾਕ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ RAG ਨੂੰ ਆਰਕੈਸਟਰੇਟ ਕਰਨ ਲਈ LangChain ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ:

``ਅਜਗਰ ਲੈਂਗਚੈਨ ਆਯਾਤ ਐਲਐਲਐਮਚੇਨ ਤੋਂ langchain.chains.openai ਤੋਂ OpenAIApi ਆਯਾਤ ਕਰੋ

LLM ਚੇਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ

llm_chain = LLMCਚੇਨ ( llm=OpenAIApi(), retrieval=LangChainRetrieval( index=LangChainIndex( name="my_index", ਦਸਤਾਵੇਜ਼=["doc1", "doc2", "doc3"] ) ) )

LLM ਚੇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਜਵਾਬ ਤਿਆਰ ਕਰੋ

ਜਵਾਬ = llm_chain.run ("RAG ਕੀ ਹੈ?")

ਪ੍ਰਿੰਟ (ਜਵਾਬ) ``

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ LangChain ਤੋਂ LLMChain ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ LLM ਚੇਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ। ਅਸੀਂ ਫਿਰ LLM ਚੇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਜਵਾਬ ਬਣਾਉਣ ਲਈ ਰਨ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।

ਟੌਪ 5-10 ਸਭ ਤੋਂ ਵੱਧ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਕਮਾਂਡਾਂ/ਸਨਿਪੇਟਸ

ਇੱਥੇ FastAPI ਅਤੇ Django ਨਾਲ RAG ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਸਭ ਤੋਂ ਵੱਧ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ 5-10 ਕਮਾਂਡਾਂ/ਸਨਿਪੇਟਸ ਹਨ:

1. ਲੈਂਗਚੈਨ ਆਯਾਤ LLMCchain ਤੋਂ: LangChain ਤੋਂ LLMChain ਕਲਾਸ ਨੂੰ ਆਯਾਤ ਕਰੋ।
2. llm_chain = LLMCchain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", ਦਸਤਾਵੇਜ਼=["doc1", "doc2", "doc3"]))): LLMC ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ LLM ਚੇਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।
3. response = llm_chain.run(query): LLM ਚੇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਜਵਾਬ ਤਿਆਰ ਕਰੋ।
4. 'ਫਾਸਟੈਪੀ ਇੰਪੋਰਟ ਫਾਸਟਏਪੀਆਈ' ਤੋਂ: ਫਾਸਟਏਪੀਆਈ ਤੋਂ 'ਫਾਸਟਏਪੀਆਈ' ਕਲਾਸ ਇੰਪੋਰਟ ਕਰੋ।
5. ਐਪ = FastAPI(): ਇੱਕ FastAPI ਐਪਲੀਕੇਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।
6. @app.get("/rag"): RAG ਅੰਤਮ ਬਿੰਦੂ ਲਈ ਇੱਕ ਰੂਟ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।
7. llm_chain = LLMCchain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", ਦਸਤਾਵੇਜ਼=["doc1", "doc2", "doc3"]))): LLMC ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ LLM ਚੇਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।
8. response = llm_chain.run(query): LLM ਚੇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਜਵਾਬ ਤਿਆਰ ਕਰੋ।
9. django.http ਤੋਂ JsonResponse ਆਯਾਤ ਕਰੋ: Django ਤੋਂ JsonResponse ਕਲਾਸ ਨੂੰ ਆਯਾਤ ਕਰੋ।
10. return JsonResponse({"response": response}): ਤਿਆਰ ਕੀਤੇ ਜਵਾਬ ਦੇ ਨਾਲ JSON ਜਵਾਬ ਵਾਪਸ ਕਰੋ।

ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ

ਇੱਥੇ Chart.js ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ RAG ਪਾਈਪਲਾਈਨ ਦਾ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਹੈ:

ਜੇਸਨ { "type": "ਲੇਟਵੀਂ ਪੱਟੀ", "ਡਾਟਾ": { "labels": ["ਮੁੜ ਪ੍ਰਾਪਤੀ", "ਪੀੜ੍ਹੀ", "ਪੋਸਟ-ਪ੍ਰੋਸੈਸਿੰਗ"], "datasets": [ { "label": "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 } ] }, "ਵਿਕਲਪ": { "ਸਿਰਲੇਖ": { "ਡਿਸਪਲੇ": ਸਹੀ, "text": "RAG ਪਾਈਪਲਾਈਨ" }, "ਪੈਮਾਨਾ": { "yAxes": [ { "ਟਿਕਸ": { "beginAtZero": ਸਹੀ } } ] } } }

ਇਹ ਦ੍ਰਿਸ਼ਟੀਕੋਣ RAG ਪਾਈਪਲਾਈਨ ਨੂੰ ਤਿੰਨ ਪੜਾਵਾਂ ਦੇ ਨਾਲ ਦਿਖਾਉਂਦਾ ਹੈ: ਮੁੜ ਪ੍ਰਾਪਤੀ, ਪੀੜ੍ਹੀ, ਅਤੇ ਪੋਸਟ-ਪ੍ਰੋਸੈਸਿੰਗ।

ਸਿੱਟਾ

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ LLM ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਵਧਾਉਣ ਲਈ FastAPI ਅਤੇ Django ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ RAG ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਪੜਚੋਲ ਕੀਤੀ, ਜਿਸ ਵਿੱਚ ਸਹਿਜ ਡਾਟਾ ਪ੍ਰਾਪਤੀ ਅਤੇ ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ LangChain ਨਾਲ ਆਰਕੈਸਟਰੇਸ਼ਨ ਸ਼ਾਮਲ ਹੈ। ਅਸੀਂ FastAPI ਅਤੇ Django ਦੇ ਨਾਲ RAG ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਇੱਕ ਵਿਹਾਰਕ ਗਾਈਡ ਵੀ ਪ੍ਰਦਾਨ ਕੀਤੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਕੋਡ ਉਦਾਹਰਨਾਂ ਅਤੇ RAG ਪਾਈਪਲਾਈਨ ਦੀ ਵਿਜ਼ੁਅਲਤਾ ਸ਼ਾਮਲ ਹੈ। ਅਸੀਂ ਉਮੀਦ ਕਰਦੇ ਹਾਂ ਕਿ ਇਸ ਲੇਖ ਨੇ ਉਹਨਾਂ ਡਿਵੈਲਪਰਾਂ ਲਈ ਇੱਕ ਉਪਯੋਗੀ ਸਰੋਤ ਪ੍ਰਦਾਨ ਕੀਤਾ ਹੈ ਜੋ ਉਹਨਾਂ ਦੀਆਂ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ RAG ਤਕਨੀਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਨ।