** நவீன வலை கட்டமைப்புகளுடன் RAG (மீட்பு-ஆக்மென்ட் ஜெனரேஷன்) ஒருங்கிணைத்தல்: ஒரு நடைமுறை வழிகாட்டி**

அறிமுகம்

சமீபத்திய ஆண்டுகளில், இயற்கை மொழி செயலாக்கத் துறை (NLP) பல்வேறு களங்களில் பெரிய மொழி மாதிரிகள் (LLMகள்) மற்றும் அவற்றின் பயன்பாடுகளின் வளர்ச்சியில் குறிப்பிடத்தக்க எழுச்சியைக் கண்டுள்ளது. இருப்பினும், எல்எல்எம்களின் முக்கிய வரம்புகளில் ஒன்று, அவற்றின் பதில்களில் வெளிப்புற அறிவை மீட்டெடுக்கவும் இணைக்கவும் இயலாமை ஆகும். இங்குதான் மீட்டெடுப்பு-ஆக்மென்டட் ஜெனரேஷன் (RAG) நுட்பங்கள் செயல்படுகின்றன. இந்தக் கட்டுரையில், இணையப் பயன்பாடுகளில் LLM திறன்களை மேம்படுத்த FastAPI மற்றும் Django ஐப் பயன்படுத்தி RAG நுட்பங்களைச் செயல்படுத்துவது பற்றி ஆராய்வோம், தடையற்ற தரவு மீட்டெடுப்பு மற்றும் செயலாக்கத்திற்காக LangChain உடன் ஆர்கெஸ்ட்ரேஷன் உட்பட.

RAG என்றால் என்ன?

RAG என்பது மிகவும் துல்லியமான மற்றும் தகவலறிந்த பதில்களை உருவாக்க, மீட்டெடுப்பு மற்றும் தலைமுறை மாதிரிகளின் வலிமையை ஒருங்கிணைக்கும் ஒரு நுட்பமாகும். RAG இன் பின்னணியில் உள்ள அடிப்படை யோசனை என்னவென்றால், முதலில் அறிவுத் தளம் அல்லது தரவுத்தளத்திலிருந்து தொடர்புடைய தகவலை மீட்டெடுக்க வேண்டும், பின்னர் ஒரு பதிலை உருவாக்க இந்தத் தகவலைப் பயன்படுத்த வேண்டும். இந்த அணுகுமுறை எல்எல்எம்களை வெளிப்புற அறிவைப் பயன்படுத்தவும் மேலும் துல்லியமான மற்றும் தகவலறிந்த பதில்களை வழங்கவும் அனுமதிக்கிறது.

FastAPI மற்றும் Django உடன் RAGஐ ஏன் பயன்படுத்த வேண்டும்?

FastAPI மற்றும் Django ஆகியவை இணைய பயன்பாடுகளை உருவாக்கப் பயன்படுத்தப்படும் மிகவும் பிரபலமான இரண்டு வலை கட்டமைப்புகள் ஆகும். வலை பயன்பாடுகளை உருவாக்குவதற்கு அவை வலுவான மற்றும் அளவிடக்கூடிய உள்கட்டமைப்பை வழங்குகின்றன, மேலும் எல்எல்எம் திறன்களை மேம்படுத்த RAG நுட்பங்களுடன் எளிதாக ஒருங்கிணைக்கப்படலாம். FastAPI என்பது ஒரு நவீன வலை கட்டமைப்பாகும், இது வலை பயன்பாடுகளை உருவாக்க விரைவான மற்றும் திறமையான வழியை வழங்குகிறது, அதே நேரத்தில் Django என்பது ஒரு உயர்-நிலை வலை கட்டமைப்பாகும், இது வலுவான வலை பயன்பாடுகளை உருவாக்குவதற்கான கட்டமைப்பு, வார்ப்புருக்கள் மற்றும் API களை வழங்குகிறது.

FastAPI உடன் RAG ஐ செயல்படுத்துதல்

RAG நுட்பங்களை செயல்படுத்துவதற்கு FastAPI எளிய மற்றும் திறமையான வழியை வழங்குகிறது. RAG ஐ செயல்படுத்த FastAPI ஐ எவ்வாறு பயன்படுத்துவது என்பதை விளக்கும் ஒரு எடுத்துக்காட்டு குறியீடு தொகுதி இங்கே:

fastapi இறக்குமதி FastAPI இலிருந்து
langchain இறக்குமதி LLMChain இலிருந்து
langchain.chains.openai இலிருந்து OpenAIApi இறக்குமதி

பயன்பாடு = FastAPI()

@app.get("/rag")
async def rag(கேள்வி: str):
    
    llm_chain = LLMCchain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            குறியீட்டு=LangChainIndex(
                name="my_index",
                ஆவணங்கள்=["doc1", "doc2", "doc3"]
            )
        )
    )

    # LLM சங்கிலியைப் பயன்படுத்தி பதிலை உருவாக்கவும்
    பதில் = llm_chain.run(கேள்வி)

    திரும்ப {"பதில்": பதில்}

இந்த எடுத்துக்காட்டில், LangChain இலிருந்து LLMChain' வகுப்பைப் பயன்படுத்தி LLM சங்கிலியை வரையறுக்கிறோம். பின்னர், LangChainRetrievalவகுப்பைப் பயன்படுத்தி மீட்டெடுப்பு கூறுகளை வரையறுக்கிறோம், இது அறிவுத் தளம் அல்லது தரவுத்தளத்திலிருந்து தொடர்புடைய தகவலைப் பெறப் பயன்படுகிறது. இறுதியாக, LLM சங்கிலியைப் பயன்படுத்தி பதிலை உருவாக்கரன்` முறையைப் பயன்படுத்துகிறோம்.

** ஜாங்கோவுடன் RAG ஐ செயல்படுத்துதல்**

RAG நுட்பங்களுடன் எளிதாக ஒருங்கிணைக்கக்கூடிய உயர்நிலை வலை கட்டமைப்பை Django வழங்குகிறது. RAG ஐ செயல்படுத்த ஜாங்கோவை எவ்வாறு பயன்படுத்துவது என்பதை விளக்கும் ஒரு எடுத்துக்காட்டு குறியீடு தொகுதி இங்கே:

django.http இலிருந்து JsonResponse இறக்குமதி
langchain இறக்குமதி LLMChain இலிருந்து
langchain.chains.openai இலிருந்து OpenAIApi இறக்குமதி

டெஃப் ராக்(கோரிக்கை):
    # எல்எல்எம் சங்கிலியை வரையறுக்கவும்
    llm_chain = LLMCchain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            குறியீட்டு=LangChainIndex(
                name="my_index",
                ஆவணங்கள்=["doc1", "doc2", "doc3"]
            )
        )
    )

    # LLM சங்கிலியைப் பயன்படுத்தி பதிலை உருவாக்கவும்
    பதில் = llm_chain.run(request.GET.get("query"))

    திரும்ப JsonResponse({"response": response})

இந்த எடுத்துக்காட்டில், வினவலை உள்ளீடாக எடுத்து, LLM சங்கிலியைப் பயன்படுத்தி பதிலை உருவாக்கும் காட்சி செயல்பாடு `ராக்' என்பதை வரையறுக்கிறோம்.

LangChain உடன் RAG ஐ ஆர்கெஸ்ட்ரேட்டிங் செய்தல்

RAG நுட்பங்களை ஒழுங்கமைக்க LangChain ஒரு எளிய மற்றும் திறமையான வழியை வழங்குகிறது. RAG ஐ எவ்வாறு ஒழுங்கமைக்க LangChain ஐப் பயன்படுத்துவது என்பதை விளக்கும் ஒரு எடுத்துக்காட்டு குறியீடு தொகுதி இங்கே:

langchain இறக்குமதி LLMChain இலிருந்து
langchain.chains.openai இலிருந்து OpenAIApi இறக்குமதி

# எல்எல்எம் சங்கிலியை வரையறுக்கவும்
llm_chain = LLMCchain(
    llm=OpenAIApi(),
    retrieval=LangChainRetrieval(
        குறியீட்டு=LangChainIndex(
            name="my_index",
            ஆவணங்கள்=["doc1", "doc2", "doc3"]
        )
    )
)

# LLM சங்கிலியைப் பயன்படுத்தி பதிலை உருவாக்கவும்
பதில் = llm_chain.run("RAG என்றால் என்ன?")

அச்சு (பதில்)

இந்த எடுத்துக்காட்டில், LangChain இலிருந்து LLMChain' வகுப்பைப் பயன்படுத்தி LLM சங்கிலியை வரையறுக்கிறோம். LLM சங்கிலியைப் பயன்படுத்தி பதிலை உருவாக்க, ரன்` முறையைப் பயன்படுத்துகிறோம்.

முதல் 5-10 அதிகம் பயன்படுத்தப்பட்ட கட்டளைகள்/துணுக்குகள்

FastAPI மற்றும் Django உடன் RAG ஐச் செயல்படுத்துவதற்கு அதிகம் பயன்படுத்தப்படும் 5-10 கட்டளைகள்/துணுக்குகள் இங்கே:

1. langchain இறக்குமதி LLMChain இலிருந்து: LangChain இலிருந்து LLMChain வகுப்பை இறக்குமதி செய்யவும்.
2. llm_chain = LLMCchain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"]))): LLMha ஐப் பயன்படுத்தி `எல்எல்எம்ஹா' வகுப்பை வரையறுக்கவும்.
3. response = llm_chain.run(query): LLM சங்கிலியைப் பயன்படுத்தி பதிலை உருவாக்கவும்.
4. Fastapi இறக்குமதி FastAPI இலிருந்து: FastAPI இலிருந்து FastAPI வகுப்பை இறக்குமதி செய்யவும்.
5. app = FastAPI(): FastAPI பயன்பாட்டை வரையறுக்கவும்.
6. @app.get("/rag"): RAG இறுதிப்புள்ளிக்கான வழியை வரையறுக்கவும்.
7. llm_chain = LLMCchain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"]))): LLMha ஐப் பயன்படுத்தி `எல்எல்எம்ஹா' வகுப்பை வரையறுக்கவும்.
8. response = llm_chain.run(query): LLM சங்கிலியைப் பயன்படுத்தி பதிலை உருவாக்கவும்.
9. django.http இறக்குமதி JsonResponse: ஜாங்கோவில் இருந்து JsonResponse வகுப்பை இறக்குமதி செய்யவும்.
10. return JsonResponse({"response": response}): உருவாக்கப்பட்ட பதிலுடன் JSON பதிலைத் தரவும்.

காட்சிப்படுத்தல்

Chart.js ஐப் பயன்படுத்தி RAG பைப்லைனின் காட்சிப்படுத்தல் இங்கே:

{
  "வகை": "கிடைமட்டப்பட்டை",
  "தரவு": {
    "லேபிள்கள்": ["மீட்பு", "தலைமுறை", "பிந்தைய செயலாக்கம்"],
    "தரவுத்தொகுப்புகள்": [
      {
        "லேபிள்": "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 பைப்லைனை மூன்று நிலைகளுடன் காட்டுகிறது: மீட்டெடுப்பு, உருவாக்கம் மற்றும் பிந்தைய செயலாக்கம்.

முடிவு

இந்தக் கட்டுரையில், இணையப் பயன்பாடுகளில் LLM திறன்களை மேம்படுத்த FastAPI மற்றும் Django ஐப் பயன்படுத்தி RAG நுட்பங்களைச் செயல்படுத்துவதை ஆராய்ந்தோம், தடையற்ற தரவு மீட்டெடுப்பு மற்றும் செயலாக்கத்திற்கான LangChain உடன் ஆர்கெஸ்ட்ரேஷன் உட்பட. குறியீட்டு எடுத்துக்காட்டுகள் மற்றும் RAG பைப்லைனின் காட்சிப்படுத்தல் உட்பட FastAPI மற்றும் Django உடன் RAG ஐ செயல்படுத்துவதற்கான நடைமுறை வழிகாட்டியையும் நாங்கள் வழங்கினோம். டெவலப்பர்கள் தங்கள் வலைப் பயன்பாடுகளில் RAG நுட்பங்களைச் செயல்படுத்த விரும்பும் ஒரு பயனுள்ள ஆதாரத்தை இந்தக் கட்டுரை வழங்கியுள்ளது என்று நம்புகிறோம்.