RAG (Retrieval-Augmented Generation) sareko esparru modernoekin integratzea: gida praktikoa

Sarrera

Azken urteotan, Hizkuntza Naturalaren Prozesamenduaren (NLP) arloak gorakada nabarmena izan du Hizkuntza Eredu Handien (LLM) eta haien aplikazioen garapenean hainbat domeinutan. Hala ere, LLMen muga nagusietako bat kanpoko ezagutza berreskuratu eta erantzunetan txertatzeko ezintasuna da. Hor sartzen dira Retrieval-Augmented Generation (RAG) teknikak. Artikulu honetan, FastAPI eta Django erabiliz RAG tekniken inplementazioa aztertuko dugu web aplikazioetan LLM gaitasunak hobetzeko, LangChain-ekin orkestrazioa barne, datuak ezin hobeto berreskuratzeko eta prozesatzeko.

Zer da RAG?

RAG Retrieval eta Generation ereduen indarrak konbinatzen dituen teknika bat da, erantzun zehatzagoak eta informatzaileagoak sortzeko. RAG atzean dagoen oinarrizko ideia lehenik eta behin ezagutza-base batetik edo datu-base batetik informazio garrantzitsua berreskuratzea da, eta ondoren informazio hori erabiltzea erantzun bat sortzeko. Ikuspegi honi esker, LLM-ek kanpoko ezagutza aprobetxa dezakete eta erantzun zehatzagoak eta informatzaileagoak eskaintzeko.

Zergatik erabili RAG FastAPI eta Django-rekin?

FastAPI eta Django web aplikazioak eraikitzeko erabiltzen diren web esparru ezagunenetako bi dira. Web aplikazioak eraikitzeko azpiegitura sendoa eta eskalagarria eskaintzen dute, eta RAG teknikekin erraz integra daitezke LLM gaitasunak hobetzeko. FastAPI web-esparru moderno bat da, web aplikazioak eraikitzeko modu azkar eta eraginkorra eskaintzen duena, eta Django, berriz, web-aplikazio sendoak eraikitzeko arkitektura, txantiloiak eta APIak eskaintzen dituen maila altuko web-esparrua da.

RAG inplementatzen FastAPI-rekin

FastAPI-k RAG teknikak ezartzeko modu sinple eta eraginkorra eskaintzen du. Hona hemen FastAPI RAG inplementatzeko nola erabili erakusten duen kode bloke adibide bat:

fastapi-tik inportatu FastAPItik
langchain import LLMChain-etik
langchain.chains.openai-tik inportatu OpenAIApi

aplikazioa = FastAPI()

@app.get ("/trapu")
async def rag (kontsulta: str):
    
    llm_chain = LLMChain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            index=LangChainIndex(
                izena = "nire_indizea",
                dokumentuak="doc1", "doc2", "doc3"]
            )
        )
    )

    # Sortu erantzun bat LLM katea erabiliz
    erantzuna = llm_chain.run (kontsulta)

    itzuli {"erantzuna": erantzuna}

Adibide honetan, LLM kate bat definitzen dugu LangChain-eko LLMCain klasea erabiliz. Ondoren, berreskuratzeko osagai bat definitzen dugu LangChainRetrieval klasea erabiliz, ezagutza-base edo datu-base batetik informazio garrantzitsua berreskuratzeko erabiltzen dena. Azkenik, exekutatu metodoa erabiltzen dugu LLM katea erabiliz erantzun bat sortzeko.

Django-rekin RAG inplementatzen

Django-k goi-mailako web esparru bat eskaintzen du, RAG teknikekin erraz integra daitekeena. Hona hemen RAG inplementatzeko Django nola erabili erakusten duen kode bloke adibide bat:

django.http inportatu JsonResponse
langchain import LLMChain-etik
langchain.chains.openai-tik inportatu OpenAIApi

def trapu(eskaera):
    # Definitu LLM katea
    llm_chain = LLMChain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            index=LangChainIndex(
                izena = "nire_indizea",
                dokumentuak="doc1", "doc2", "doc3"]
            )
        )
    )

    # Sortu erantzun bat LLM katea erabiliz
    erantzuna = llm_chain.run (request.GET.get ("kontsulta"))

    itzuli JsonResponse({"erantzuna": erantzuna})

Adibide honetan, trapua ikuspegi-funtzioa definitzen dugu, kontsulta bat sarrera gisa hartzen duena eta LLM katea erabiliz erantzuna sortzen duena.

** LangChain-ekin RAG orkestratzen**

LangChain-ek RAG teknikak orkestratzeko modu sinple eta eraginkorra eskaintzen du. Hona hemen LangChain RAG orkestratzeko nola erabili erakusten duen kode bloke adibide bat:

langchain import LLMChain-etik
langchain.chains.openai-tik inportatu OpenAIApi

# Definitu LLM katea
llm_chain = LLMChain(
    llm=OpenAIApi(),
    retrieval=LangChainRetrieval(
        index=LangChainIndex(
            izena = "nire_indizea",
            dokumentuak="doc1", "doc2", "doc3"]
        )
    )
)

# Sortu erantzun bat LLM katea erabiliz
erantzuna = llm_chain.run ("Zer da RAG?")

inprimatu (erantzuna)

Adibide honetan, LLM kate bat definitzen dugu LangChain-eko LLMCain klasea erabiliz. Ondoren, exekutatu metodoa erabiltzen dugu LLM katea erabiliz erantzun bat sortzeko.

Erabiltzen diren 5-10 komando/zati nagusiak

Hona hemen FastAPI eta Django-rekin RAG inplementatzeko gehien erabiltzen diren 5-10 komandoak/zatiak:

1. from langchain import LLMChain: Inportatu LLMCain klasea LangChain-etik.
2. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"]))): Definitu LLM kate bat LLMCain klasea erabiliz.
3. response = llm_chain.run(query): Sortu erantzun bat LLM katea erabiliz.
4. from fastapi import FastAPI: inportatu FastAPI klasea FastAPItik.
5. app = FastAPI(): Definitu FastAPI aplikazio bat.
6. @app.get("/rag"): definitu RAG amaierako punturako ibilbide bat.
7. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"]))): Definitu LLM kate bat LLMCain klasea erabiliz.
8. response = llm_chain.run(query): Sortu erantzun bat LLM katea erabiliz.
9. from django.http import JsonResponse: Inportatu JsonResponse klasea Djangotik.
10. return JsonResponse({"response": response}): JSON erantzuna itzultzen du sortutako erantzunarekin.

Bistaratzea

Hona hemen Chart.js erabiliz RAG kanalizazioaren bistaratzea:

{
  "mota": "Barra horizontala",
  "datuak": {
    "labels": ["Berreskuratzea", "Sorkuntza", "Ondoren prozesatzea"],
    "datu multzoak": [
      {
        "label": "RAG Pipeline",
        "datuak": [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)"
        ],
        "borderWidth": 1
      }
    ]
  },
  "aukerak": {
    "izenburua": {
      "bistaratu": egia,
      "text": "RAG Pipeline"
    },
    "eskalak": {
      "yAxes": [
        {
          "ticks": {
            "beginAtZero": egia
          }
        }
      ]
    }
  }
}

Bistaratze honek RAG kanalizazioa erakusten du hiru faserekin: berreskuratzea, sortzea eta postprozesatzea.

Ondorioa

Artikulu honetan, FastAPI eta Django erabiliz RAG tekniken inplementazioa aztertu dugu web aplikazioetan LLM gaitasunak hobetzeko, LangChain-ekin orkestrazioa barne, datuak ezin hobeto berreskuratzeko eta prozesatzeko. RAG FastAPI eta Djangorekin inplementatzeko gida praktiko bat ere eman dugu, kode-adibideak eta RAG kanalizazioaren bistaratzea barne. Espero dugu artikulu honek baliabide erabilgarria eskaini izana RAG teknikak beren web aplikazioetan inplementatu nahi dituzten garatzaileentzat.