Yekkirina RAG (Nifşa Vegerandin-Zêdekirî) bi Çarçoveyên Webê yên Nûjen: Rêbernameyek Pratîk

Destpêk

Di salên dawî de, qada Pêvajoya Zimanê Xwezayî (NLP) di pêşkeftina Modelên Zimanên Mezin (LLM) û serîlêdanên wan de di warên cihêreng de şahidiyek girîng e. Lêbelê, yek ji tixûbên sereke yên LLM-an nebûna wan e ku zanyariyên derveyî di bersivên xwe de bistînin û tevlihev bikin. Li vir teknîkên Retrieval-Augmented Generation (RAG) dileyizin. Di vê gotarê de, em ê pêkanîna teknîkên RAG-ê bi karanîna FastAPI û Django vekolînin da ku kapasîteyên LLM-ê di serîlêdanên malperê de zêde bikin, di nav de orkestrasyona bi LangChain re ji bo vegerandin û hilanîna daneya bêkêmasî.

RAG çi ye?

RAG teknîkek e ku hêza modelên Retrieval û Generation berhev dike da ku bersivên rast û agahdartir hilberîne. Fikra bingehîn a li pişt RAG ev e ku meriv pêşî agahdariya têkildar ji bingehek zanînê an databasek bigire, û dûv re vê agahiyê bikar bîne da ku bersivek çêbike. Ev nêzîkatî destûrê dide LLM-an ku zanyariyên derveyî bikar bînin û bersivên rast û agahdartir peyda bikin.

Çima RAG bi FastAPI û Django re bikar bînin?

FastAPI û Django du çarçoveyên webê yên herî populer in ku ji bo avakirina serîlêdanên malperê têne bikar anîn. Ew ji bo avakirina serîlêdanên webê binesaziyek zexm û berbelav peyda dikin, û dikarin bi hêsanî bi teknîkên RAG-ê re werin yek kirin da ku kapasîteyên LLM zêde bikin. FastAPI çarçoveyek webê ya nûjen e ku ji bo avakirina serîlêdanên malperê rêyek bilez û bikêr peyda dike, dema ku Django çarçoveyek malperê ya asta bilind e ku mîmarî, şablon û API-yan ji bo avakirina serîlêdanên malperê yên bihêz peyda dike.

Pêkanîna RAG bi FastAPI re

FastAPI ji bo pêkanîna teknîkên RAG rêyek hêsan û bikêr peyda dike. Li vir mînakek bloka kodê heye ku destnîşan dike ka meriv çawa FastAPI bikar tîne da ku RAG bicîh bîne:

`` python ji fastapi import FastAPI ji langchain import LLMChain ji langchain.chains.openai import OpenAIApi

sepan = FastAPI()

@app.get ("/rag") async def rag (pirsîn: str):

llm_zincîra = LLMCchain(
    llm=OpenAIApi(),
    retrieval=LangChainRetrieval(
        index=LangChainIndex(
            nav = "min_index",
            belge = ["doc1", "doc2", "doc3"]
        )
    )
)

# Bi karanîna zincîra LLM re bersivek çêbikin
bersiv = llm_chain.run (pirsîn)

vegera {"bersiv": bersiv}

Di vê nimûneyê de, em zincîreyek LLM-ê bi karanîna çîna `LLMChain` ji LangChain destnîşan dikin. Dûv re em bi karanîna çîna `LangChainRetrieval`, ku ji bo wergirtina agahdariya têkildar ji bingehek zanînê an databasek tê bikar anîn, hêmanek vegerandinê diyar dikin. Di dawiyê de, em rêbaza `run` bikar tînin ku bi karanîna zincîra LLM bersivek çêbikin.

** Pêkanîna RAG bi Django re **


Django çarçoveyek malperê ya asta bilind peyda dike ku dikare bi teknîkên RAG-ê re bi hêsanî were yek kirin. Li vir mînakek bloka kodê heye ku destnîşan dike ka meriv çawa Django ji bo pêkanîna RAG bikar tîne:

`` python
ji django.http import JsonResponse
ji langchain import LLMChain
ji langchain.chains.openai import OpenAIApi

def rag (daxwaz):
    # Zincîra LLM diyar bikin
    llm_zincîra = LLMCchain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            index=LangChainIndex(
                nav = "min_index",
                belge = ["doc1", "doc2", "doc3"]
            )
        )
    )

    # Bi karanîna zincîra LLM re bersivek çêbikin
    bersiv = llm_chain.run(request.GET.get("pirsîn"))

    vegere JsonResponse ({"bersiv": bersiv})

Di vê nimûneyê de, em fonksiyonek dîtinê rag diyar dikin ku pirsek wekî têketinê digire û bi karanîna zincîra LLM bersivek çêdike.

Orkestrakirina RAG bi LangChain

LangChain rêgezek hêsan û bikêrhatî peyda dike ku teknîkên RAG-ê saz bike. Li vir mînakek bloka kodê heye ku destnîşan dike ka meriv çawa LangChain bikar tîne da ku RAG saz bike:

`` python ji langchain import LLMChain ji langchain.chains.openai import OpenAIApi

Zincîra LLM diyar bikin

llm_zincîra = LLMCchain( llm=OpenAIApi(), retrieval=LangChainRetrieval( index=LangChainIndex( nav = "min_index", belge = ["doc1", "doc2", "doc3"] ) ) )

Bi karanîna zincîra LLM re bersivek çêbikin

bersiv = llm_chain.run ("RAG çi ye?")

çapkirin (bersiv)

Di vê nimûneyê de, em zincîreyek LLM-ê bi karanîna çîna `LLMChain` ji LangChain destnîşan dikin. Dûv re em rêbaza `run` bikar tînin da ku bi karanîna zincîra LLM bersivek çêbikin.

** Serê 5-10 Fermanên Herî Bikaranîn / Parçeyên **


Li vir 5-10 fermanên herî zêde têne bikar anîn ji bo pêkanîna RAG bi FastAPI û Django re hene:

1. `ji importa langchain LLMChain`: Dersa `LLMChain` ji LangChain derxînin.
2. `llm_zincîra = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", belge=["doc1", "doc2", "doc3"])))": Zincîrek LLM`ê bi karanîna çîna `LLMCha` diyar bike
3. `bersiv = llm_chain.run(pirsîn)`: Bi karanîna zincîra LLM bersivek çêbike.
4. `ji fastAPI import FastAPI`: Dersa `FastAPI` ji FastAPI derxînin.
5. `app = FastAPI()`: Serlêdanek FastAPI diyar bike.
6. `@app.get("/rag")`: Ji bo xala dawiya RAG rêyek diyar bike.
7. `llm_zincîra = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", belge=["doc1", "doc2", "doc3"])))": Zincîrek LLM`ê bi karanîna çîna `LLMCha` destnîşan bikin.
8. `bersiv = llm_chain.run(pirsîn)`: Bi karanîna zincîra LLM bersivek çêbike.
9. `ji django.http import JsonResponse`: Dersa `JsonResponse` ji Django derxîne.
10. `JsonResponse vegere({"bersiv": bersiv})`: Bersiva JSON bi bersiva hatî çêkirin vegerîne.

**Visualization **


Li vir dîmenek lûleya RAG-ê bi karanîna Chart.js heye:

```json
{
  "type": "HorizontalBar",
  "dane": {
    "labels": ["Vegerandin", "Nifş", "Pişt-pêvajo"],
    "daneyên": [
      {
        "label": "Rag Pipeline",
        "dane": [10, 20, 30],
        "backgroundColor": [
          "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)"
        ],
        "Berfirehiya sînor": 1
      }
    ]
  },
  "vebijark": {
    "sernav": {
      "nîşandan": rast,
      "text": "Rag Pipeline"
    },
    "pîvan": {
      "yAxes": [
        {
          "tik": {
            "beginAtZero": rast
          }
        }
      ]
    }
  }
}

Ev dîtbarî boriyê RAG-ê bi sê qonaxan nîşan dide: wergirtin, nifşkirin, û paş-pêvajoyê.

** Encam **

Di vê gotarê de, me pêkanîna teknîkên RAG-ê bi karanîna FastAPI û Django vekoland da ku kapasîteyên LLM-ê di serîlêdanên webê de zêde bikin, tevî orkestrasyona bi LangChain re ji bo vegerandin û hilanîna daneya bêkêmasî. Me di heman demê de rêbernameyek pratîkî ji bo pêkanîna RAG bi FastAPI û Django re peyda kir, di nav de mînakên kodê û dîmenek boriya RAG. Em hêvî dikin ku ev gotar ji bo pêşdebiran ku digerin ku teknîkên RAG-ê di serîlêdanên xwe yên malperê de bicîh bikin çavkaniyek kêrhatî peyda kiriye.