ଆଧୁନିକ ୱେବ୍ ଫ୍ରେମୱାର୍କ ସହିତ RAG (ପୁନରୁଦ୍ଧାର-ଅଗମେଣ୍ଟେଡ୍ ଜେନେରେସନ୍) ଏକୀକରଣ: ଏକ ବ୍ୟବହାରିକ ଗାଇଡ୍

ପରିଚୟ

ସାମ୍ପ୍ରତିକ ବର୍ଷଗୁଡିକରେ, ପ୍ରାକୃତିକ ଭାଷା ପ୍ରକ୍ରିୟାକରଣ (NLP) କ୍ଷେତ୍ରରେ ବଡ଼ ଭାଷା ମଡେଲ (LLM) ର ବିକାଶ ଏବଂ ବିଭିନ୍ନ ଡୋମେନରେ ସେମାନଙ୍କର ପ୍ରୟୋଗରେ ଉଲ୍ଲେଖନୀୟ ବୃଦ୍ଧି ଘଟିଛି | ଅବଶ୍ୟ, LLM ଗୁଡ଼ିକର ଏକ ପ୍ରମୁଖ ସୀମାବଦ୍ଧତା ହେଉଛି ସେମାନଙ୍କର ପ୍ରତିକ୍ରିୟାରେ ବାହ୍ୟ ଜ୍ଞାନ ପୁନରୁଦ୍ଧାର ଏବଂ ଅନ୍ତର୍ଭୂକ୍ତ କରିବାରେ ସେମାନଙ୍କର ଅକ୍ଷମତା | ଏହିଠାରେ ପୁନରୁଦ୍ଧାର-ଅଗମେଣ୍ଟେଡ୍ ଜେନେରେସନ୍ (RAG) କ ques ଶଳଗୁଡ଼ିକ କାର୍ଯ୍ୟକାରୀ ହୁଏ | ଏହି ଆର୍ଟିକିଲରେ, ୱେବ୍ ପ୍ରୟୋଗଗୁଡ଼ିକରେ LLM କ୍ଷମତାକୁ ବ to ାଇବା ପାଇଁ ଫାଷ୍ଟପିଏ ଏବଂ Django ବ୍ୟବହାର କରି RAG କ ques ଶଳର କାର୍ଯ୍ୟକାରିତା ବିଷୟରେ ଅନୁସନ୍ଧାନ କରିବୁ, ବିନା ତଥ୍ୟ ପୁନରୁଦ୍ଧାର ଏବଂ ପ୍ରକ୍ରିୟାକରଣ ପାଇଁ ଲ୍ୟାଙ୍ଗଚେନ ସହିତ ଅର୍କେଷ୍ଟ୍ରେସନ୍ ସହିତ |

RAG କ’ଣ?

RAG ହେଉଛି ଏକ କ que ଶଳ ଯାହା ପୁନରୁଦ୍ଧାର ଏବଂ ଜେନେରେସନ୍ ମଡେଲଗୁଡିକର ଶକ୍ତିଗୁଡ଼ିକୁ ଏକତ୍ର କରି ଅଧିକ ସଠିକ୍ ଏବଂ ସୂଚନାପୂର୍ଣ୍ଣ ପ୍ରତିକ୍ରିୟା ସୃଷ୍ଟି କରେ | RAG ପଛରେ ଥିବା ମ idea ଳିକ ଧାରଣା ହେଉଛି ପ୍ରଥମେ ଏକ ଜ୍ଞାନ ଆଧାର କିମ୍ବା ଡାଟାବେସ୍ ରୁ ପ୍ରାସଙ୍ଗିକ ସୂଚନା ପୁନରୁଦ୍ଧାର କରିବା, ଏବଂ ତାପରେ ଏକ ପ୍ରତିକ୍ରିୟା ସୃଷ୍ଟି କରିବାକୁ ଏହି ସୂଚନା ବ୍ୟବହାର କରିବା | ଏହି ପଦ୍ଧତି LLM ଗୁଡ଼ିକୁ ବାହ୍ୟ ଜ୍ଞାନକୁ ବ୍ୟବହାର କରିବାକୁ ଏବଂ ଅଧିକ ସଠିକ୍ ଏବଂ ସୂଚନାପୂର୍ଣ୍ଣ ପ୍ରତିକ୍ରିୟା ପ୍ରଦାନ କରିବାକୁ ଅନୁମତି ଦିଏ |

FastAPI ଏବଂ Django ସହିତ RAG କାହିଁକି ବ୍ୟବହାର କରନ୍ତି?

ୱେବ୍ ଆପ୍ଲିକେସନ୍ ଗଠନ ପାଇଁ ବ୍ୟବହୃତ ଫାଷ୍ଟପି ଏବଂ Django ହେଉଛି ଦୁଇଟି ଲୋକପ୍ରିୟ ୱେବ୍ framework ାଞ୍ଚା | ୱେବ୍ ପ୍ରୟୋଗଗୁଡ଼ିକ ନିର୍ମାଣ ପାଇଁ ସେମାନେ ଏକ ଦୃ ust ଏବଂ ମାପନୀୟ ଭିତ୍ତିଭୂମି ପ୍ରଦାନ କରନ୍ତି, ଏବଂ LLM କ୍ଷମତା ବ to ାଇବା ପାଇଁ RAG କ ques ଶଳ ସହିତ ସହଜରେ ଏକୀଭୂତ ହୋଇପାରିବ | FastAPI ହେଉଛି ଏକ ଆଧୁନିକ ୱେବ୍ framework ାଞ୍ଚା ଯାହା ୱେବ୍ ଆପ୍ଲିକେସନ୍ ଗଠନ ପାଇଁ ଏକ ଦ୍ରୁତ ଏବଂ ଦକ୍ଷ ଉପାୟ ପ୍ରଦାନ କରୁଥିବାବେଳେ Django ହେଉଛି ଏକ ଉଚ୍ଚ ସ୍ତରୀୟ ୱେବ୍ framework ାଞ୍ଚା ଯାହା ଦୃ ust ୱେବ୍ ପ୍ରୟୋଗ ଗଠନ ପାଇଁ ଏକ ସ୍ଥାପତ୍ୟ, ଟେମ୍ପଲେଟ୍ ଏବଂ API ପ୍ରଦାନ କରିଥାଏ |

FastAPI ସହିତ RAG କାର୍ଯ୍ୟକାରୀ କରିବା

RAG କ ques ଶଳଗୁଡିକ କାର୍ଯ୍ୟକାରୀ କରିବା ପାଇଁ FastAPI ଏକ ସରଳ ଏବଂ ଦକ୍ଷ ଉପାୟ ପ୍ରଦାନ କରେ | ଏଠାରେ ଏକ ଉଦାହରଣ କୋଡ୍ ବ୍ଲକ୍ ଅଛି ଯାହା RAG କୁ କାର୍ଯ୍ୟକାରୀ କରିବା ପାଇଁ FastAPI କିପରି ବ୍ୟବହାର କରାଯିବ ତାହା ଦର୍ଶାଏ:

"ପାଇଥନ୍ | ଫାଷ୍ଟାପି ଆମଦାନୀ FastAPI ରୁ | langchain ଆମଦାନି LLMChain ରୁ | langchain.chains.openai ରୁ OpenAIApi ଆମଦାନି କରନ୍ତୁ |

app = FastAPI ()

@ app.get ("/ rag") async def rag (ଜିଜ୍ଞାସା: str):

llm_chain = LLMChain (
    llm = OpenAIApi (),
    ପୁନରୁଦ୍ଧାର = LangChainRetrieval (
        index = LangChainIndex (
            ନାମ = "my_index",
            ଡକ୍ୟୁମେଣ୍ଟ୍ = ["doc1", "doc2", "doc3"]
        )
    )
)

# LLM ଶୃଙ୍ଖଳା ବ୍ୟବହାର କରି ଏକ ପ୍ରତିକ୍ରିୟା ସୃଷ୍ଟି କରନ୍ତୁ |
ପ୍ରତିକ୍ରିୟା = llm_chain.run (ଜିଜ୍ଞାସା)

ଫେରସ୍ତ {"ପ୍ରତିକ୍ରିୟା": ପ୍ରତିକ୍ରିୟା}

``

ଏହି ଉଦାହରଣରେ, ଆମେ LangChain ରୁ "LLMChain" ଶ୍ରେଣୀ ବ୍ୟବହାର କରି ଏକ LLM ଶୃଙ୍ଖଳା ବ୍ୟାଖ୍ୟା କରୁ | ତାପରେ ଆମେ "LangChainRetrieval" ଶ୍ରେଣୀ ବ୍ୟବହାର କରି ଏକ ପୁନରୁଦ୍ଧାର ଉପାଦାନକୁ ବ୍ୟାଖ୍ୟା କରୁ, ଯାହା ଏକ ଜ୍ଞାନ ଆଧାର କିମ୍ବା ଡାଟାବେସ୍ ରୁ ପ୍ରାସଙ୍ଗିକ ସୂଚନା ପୁନରୁଦ୍ଧାର ପାଇଁ ବ୍ୟବହୃତ ହୁଏ | ଶେଷରେ, LLM ଶୃଙ୍ଖଳା ବ୍ୟବହାର କରି ଏକ ପ୍ରତିକ୍ରିୟା ସୃଷ୍ଟି କରିବାକୁ ଆମେ “ରନ୍” ପଦ୍ଧତି ବ୍ୟବହାର କରୁ |

Django ସହିତ RAG କାର୍ଯ୍ୟକାରୀ କରିବା

Django ଏକ ଉଚ୍ଚ ସ୍ତରୀୟ ୱେବ୍ framework ାଞ୍ଚା ପ୍ରଦାନ କରେ ଯାହା RAG କ ques ଶଳ ସହିତ ସହଜରେ ସଂଯୁକ୍ତ ହୋଇପାରିବ | ଏଠାରେ ଏକ ଉଦାହରଣ କୋଡ୍ ବ୍ଲକ୍ ଅଛି ଯାହା RAG କୁ କାର୍ଯ୍ୟକାରୀ କରିବା ପାଇଁ Django କୁ କିପରି ବ୍ୟବହାର କରାଯିବ ତାହା ଦର୍ଶାଏ:

"ପାଇଥନ୍ | django.http ଆମଦାନି JsonResponse ରୁ | langchain ଆମଦାନି LLMChain ରୁ | langchain.chains.openai ରୁ OpenAIApi ଆମଦାନି କରନ୍ତୁ |

def rag (ଅନୁରୋଧ): # LLM ଶୃଙ୍ଖଳାକୁ ବ୍ୟାଖ୍ୟା କରନ୍ତୁ | llm_chain = LLMChain ( llm = OpenAIApi (), ପୁନରୁଦ୍ଧାର = LangChainRetrieval ( index = LangChainIndex ( ନାମ = "my_index", ଡକ୍ୟୁମେଣ୍ଟ୍ = ["doc1", "doc2", "doc3"] ) ) )

# LLM ଶୃଙ୍ଖଳା ବ୍ୟବହାର କରି ଏକ ପ୍ରତିକ୍ରିୟା ସୃଷ୍ଟି କରନ୍ତୁ |
ପ୍ରତିକ୍ରିୟା = llm_chain.run (ଅନୁରୋଧ। GET.get ("ଜିଜ୍ଞାସା"))

JsonResponse ଫେରସ୍ତ ({"ପ୍ରତିକ୍ରିୟା": ପ୍ରତିକ୍ରିୟା})

``

ଏହି ଉଦାହରଣରେ, ଆମେ ଏକ ଭ୍ୟୁ ଫଙ୍କସନ୍ “rag” କୁ ବ୍ୟାଖ୍ୟା କରୁ ଯାହା ଇନପୁଟ୍ ଭାବରେ ଏକ ଜିଜ୍ଞାସା ନେଇଥାଏ ଏବଂ LLM ଶୃଙ୍ଖଳା ବ୍ୟବହାର କରି ଏକ ପ୍ରତିକ୍ରିୟା ସୃଷ୍ଟି କରେ |

LangChain ସହିତ RAG ର ଅର୍କେଷ୍ଟ୍ରିଂ

ଲ୍ୟାଙ୍ଗ ଚେନ୍ RAG କ ques ଶଳଗୁଡ଼ିକର ଅର୍କେଷ୍ଟ୍ରେଟ୍ ପାଇଁ ଏକ ସରଳ ଏବଂ ଦକ୍ଷ ଉପାୟ ପ୍ରଦାନ କରେ | ଏଠାରେ ଏକ ଉଦାହରଣ କୋଡ୍ ବ୍ଲକ୍ ଅଛି ଯାହାକି RAG ର ଅର୍କେଷ୍ଟ୍ରେଟ୍ ପାଇଁ ଲ୍ୟାଙ୍ଗ୍ ଚେନ୍ କିପରି ବ୍ୟବହାର କରାଯିବ ତାହା ଦର୍ଶାଏ:

"ପାଇଥନ୍ | langchain ଆମଦାନି LLMChain ରୁ | langchain.chains.openai ରୁ OpenAIApi ଆମଦାନି କରନ୍ତୁ |

LLM ଶୃଙ୍ଖଳାକୁ ବ୍ୟାଖ୍ୟା କରନ୍ତୁ |

llm_chain = LLMChain ( llm = OpenAIApi (), ପୁନରୁଦ୍ଧାର = LangChainRetrieval ( index = LangChainIndex ( ନାମ = "my_index", ଡକ୍ୟୁମେଣ୍ଟ୍ = ["doc1", "doc2", "doc3"] ) ) )

LLM ଶୃଙ୍ଖଳା ବ୍ୟବହାର କରି ଏକ ପ୍ରତିକ୍ରିୟା ସୃଷ୍ଟି କରନ୍ତୁ |

ପ୍ରତିକ୍ରିୟା = llm_chain.run ("RAG କ’ଣ?")

ମୁଦ୍ରଣ (ପ୍ରତିକ୍ରିୟା) ``

ଏହି ଉଦାହରଣରେ, ଆମେ LangChain ରୁ "LLMChain" ଶ୍ରେଣୀ ବ୍ୟବହାର କରି ଏକ LLM ଶୃଙ୍ଖଳା ବ୍ୟାଖ୍ୟା କରୁ | ତାପରେ LLM ଶୃଙ୍ଖଳା ବ୍ୟବହାର କରି ଏକ ପ୍ରତିକ୍ରିୟା ସୃଷ୍ଟି କରିବାକୁ ଆମେ “ରନ୍” ପଦ୍ଧତି ବ୍ୟବହାର କରୁ |

ଶ୍ରେଷ୍ଠ 5-10 ସର୍ବାଧିକ ବ୍ୟବହୃତ ନିର୍ଦ୍ଦେଶ / ସ୍ନିପେଟ୍

FastAPI ଏବଂ Django ସହିତ RAG କାର୍ଯ୍ୟକାରୀ କରିବା ପାଇଁ ଏଠାରେ ସର୍ବାଧିକ 5-10 ସର୍ବାଧିକ ବ୍ୟବହୃତ ନିର୍ଦ୍ଦେଶ / ସ୍ନିପେଟ୍ ଅଛି:

1। ।। 3। "ପ୍ରତିକ୍ରିୟା = llm_chain.run (ଜିଜ୍ଞାସା)": LLM ଶୃଙ୍ଖଳା ବ୍ୟବହାର କରି ଏକ ପ୍ରତିକ୍ରିୟା ସୃଷ୍ଟି କରନ୍ତୁ | 4। 5। "App = FastAPI ()": ଏକ FastAPI ପ୍ରୟୋଗକୁ ବ୍ୟାଖ୍ୟା କରନ୍ତୁ | 6। "@ App.get (" / rag "): RAG ଶେଷ ପଏଣ୍ଟ ପାଇଁ ଏକ ମାର୍ଗ ବ୍ୟାଖ୍ୟା କରନ୍ତୁ | 7। "Llm_chain = LLMChain (llm = OpenAIApi (), ପୁନରୁଦ୍ଧାର = LangChainRetrieval (index = LangChainIndex (name =" my_index ", ଡକ୍ୟୁମେଣ୍ଟ୍ = 8। "ପ୍ରତିକ୍ରିୟା = llm_chain.run (ଜିଜ୍ଞାସା)": LLM ଶୃଙ୍ଖଳା ବ୍ୟବହାର କରି ଏକ ପ୍ରତିକ୍ରିୟା ସୃଷ୍ଟି କରନ୍ତୁ | 9। "Django.http ରୁ JsonResponse" ଆମଦାନି କରନ୍ତୁ: Django ରୁ "JsonResponse" ଶ୍ରେଣୀ ଆମଦାନୀ କରନ୍ତୁ | 10। "ଫେରସ୍ତ JsonResponse ({" ପ୍ରତିକ୍ରିୟା ": ପ୍ରତିକ୍ରିୟା}): ସୃଷ୍ଟି ହୋଇଥିବା ପ୍ରତିକ୍ରିୟା ସହିତ ଏକ 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)" ], "borderColor": [ "rgba (255, 99, 132, 1)", "rgba (54, 162, 235, 1)", "rgba (255, 206, 86, 1)" ], "ସୀମା ଓସାର": 1 } ] }, "ବିକଳ୍ପଗୁଡିକ": { "ଆଖ୍ୟା": { "ପ୍ରଦର୍ଶନ": ସତ୍ୟ, "ପାଠ୍ୟ": "RAG ପାଇପଲାଇନ" }, "ମାପ": { "yAxes": [ { "ଟିକ୍ସ": { "startAtZero": ସତ୍ୟ | } } ] } } }

ଏହି ଭିଜୁଆଲାଇଜେସନ୍ RAG ପାଇପଲାଇନକୁ ତିନୋଟି ପର୍ଯ୍ୟାୟ ସହିତ ଦର୍ଶାଏ: ପୁନରୁଦ୍ଧାର, ଉତ୍ପାଦନ ଏବଂ ପରବର୍ତ୍ତୀ ପ୍ରକ୍ରିୟାକରଣ |

ସିଦ୍ଧାନ୍ତ

ଏହି ଆର୍ଟିକିଲରେ, ଆମେ ୱେବ୍ ପ୍ରୟୋଗଗୁଡ଼ିକରେ LLM କ୍ଷମତାକୁ ବ enhance ାଇବା ପାଇଁ ଫାଷ୍ଟପିଏ ଏବଂ Django ବ୍ୟବହାର କରି RAG କ ques ଶଳର କାର୍ଯ୍ୟକାରିତା ବିଷୟରେ ଅନୁସନ୍ଧାନ କରିଛୁ, ନିରବିହୀନ ତଥ୍ୟ ପୁନରୁଦ୍ଧାର ଏବଂ ପ୍ରକ୍ରିୟାକରଣ ପାଇଁ ଲ୍ୟାଙ୍ଗ ଚେନ୍ ସହିତ ଅର୍କେଷ୍ଟ୍ରେସନ୍ ଅନ୍ତର୍ଭୁକ୍ତ କରି | ଆମେ FastAPI ଏବଂ Django ସହିତ RAG କାର୍ଯ୍ୟକାରୀ କରିବା ପାଇଁ ଏକ ବ୍ୟବହାରିକ ଗାଇଡ୍ ପ୍ରଦାନ କରିଛୁ, କୋଡ୍ ଉଦାହରଣ ଏବଂ RAG ପାଇପଲାଇନର ଏକ ଭିଜୁଆଲାଇଜେସନ୍ ସହିତ | ଆମେ ଆଶା କରୁ ଯେ ଏହି ଆର୍ଟିକିଲ୍ ସେମାନଙ୍କ ୱେବ୍ ପ୍ରୟୋଗରେ RAG କ ques ଶଳ ପ୍ରୟୋଗ କରିବାକୁ ଚାହୁଁଥିବା ବିକାଶକାରୀଙ୍କ ପାଇଁ ଏକ ଉପଯୋଗୀ ଉତ୍ସ ପ୍ରଦାନ କରିଛି |