** RAG (Retrieval-Augmented Generation) integravimas su moderniais žiniatinklio pagrindais: praktinis vadovas**

Įvadas

Pastaraisiais metais natūralios kalbos apdorojimo (NLP) srityje pastebimas didelis didelių kalbų modelių (LLM) ir jų pritaikymo įvairiose srityse šuolis. Tačiau vienas iš pagrindinių LLM apribojimų yra jų nesugebėjimas gauti ir įtraukti išorinių žinių į savo atsakymus. Čia pradedami naudoti „Retrieval-Augmented Generation“ (RAG) metodai. Šiame straipsnyje mes išnagrinėsime RAG metodų įgyvendinimą naudojant FastAPI ir Django, kad pagerintume LLM galimybes žiniatinklio programose, įskaitant orkestravimą su LangChain, kad būtų galima sklandžiai gauti ir apdoroti duomenis.

Kas yra RAG?

RAG yra metodas, kuris sujungia stipriąsias paieškos ir generavimo modelių puses, kad būtų galima gauti tikslesnius ir informatyvesnius atsakymus. Pagrindinė RAG idėja yra pirmiausia gauti atitinkamą informaciją iš žinių bazės arba duomenų bazės, o tada naudoti šią informaciją atsakymui generuoti. Šis metodas leidžia LLM panaudoti išorines žinias ir pateikti tikslesnius bei informatyvesnius atsakymus.

Kodėl naudoti RAG su FastAPI ir Django?

FastAPI ir Django yra dvi populiariausios žiniatinklio sistemos, naudojamos kuriant žiniatinklio programas. Jie suteikia tvirtą ir keičiamo dydžio infrastruktūrą žiniatinklio programoms kurti ir gali būti lengvai integruoti su RAG metodais, kad pagerintų LLM galimybes. „FastAPI“ yra moderni žiniatinklio sistema, suteikianti greitą ir efektyvų būdą kurti žiniatinklio programas, o „Django“ yra aukšto lygio žiniatinklio sistema, teikianti architektūrą, šablonus ir API, skirtus tvirtoms žiniatinklio programoms kurti.

RAG diegimas naudojant FastAPI

FastAPI yra paprastas ir efektyvus būdas įdiegti RAG metodus. Pateikiame kodo bloko pavyzdį, kuriame parodyta, kaip naudoti FastAPI RAG diegti:

iš fastapi importuoti FastAPI
iš langchain importo LLMChain
iš langchain.chains.openai importuoti OpenAIApi

programa = FastAPI ()

@app.get("/rag")
async def rag(query: str):
    
    llm_chain = LLMchain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            index=LangChainIndex(
                name="mano_indeksas",
                document=["doc1", "doc2", "doc3"]
            )
        )
    )

    # Sugeneruokite atsakymą naudodami LLM grandinę
    atsakymas = llm_chain.run(query)

    return {"response": response}

Šiame pavyzdyje mes apibrėžiame LLM grandinę naudodami „LLMChain“ klasę iš „LangChain“. Tada apibrėžiame paieškos komponentą naudodami „LangChainRetrieval“ klasę, kuri naudojama norint gauti svarbią informaciją iš žinių bazės arba duomenų bazės. Galiausiai, mes naudojame „paleisti“ metodą atsakymui generuoti naudodami LLM grandinę.

** RAG įgyvendinimas su Django**

„Django“ teikia aukšto lygio žiniatinklio sistemą, kurią galima lengvai integruoti su RAG technologijomis. Pateikiame kodo bloko pavyzdį, kuris parodo, kaip naudoti „Django“ įgyvendinant RAG:

iš django.http importuoti JsonResponse
iš langchain importo LLMChain
iš langchain.chains.openai importuoti OpenAIApi

def rag (užklausa):
    # Apibrėžkite LLM grandinę
    llm_chain = LLMchain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            index=LangChainIndex(
                name="mano_indeksas",
                document=["doc1", "doc2", "doc3"]
            )
        )
    )

    # Sugeneruokite atsakymą naudodami LLM grandinę
    atsakymas = llm_chain.run(request.GET.get("užklausa"))

    return JsonResponse({"atsakymas": atsakymas})

Šiame pavyzdyje apibrėžiame rodinio funkciją „rag“, kuri kaip įvestį priima užklausą ir generuoja atsakymą naudodama LLM grandinę.

** RAG orkestravimas naudojant „LangChain“**

„LangChain“ yra paprastas ir efektyvus būdas suderinti RAG metodus. Pateikiame kodo bloko pavyzdį, kuris parodo, kaip naudoti „LangChain“ RAG orkestruoti:

iš langchain importo LLMChain
iš langchain.chains.openai importuoti OpenAIApi

# Apibrėžkite LLM grandinę
llm_chain = LLMchain(
    llm=OpenAIApi(),
    retrieval=LangChainRetrieval(
        index=LangChainIndex(
            name="mano_indeksas",
            document=["doc1", "doc2", "doc3"]
        )
    )
)

# Sugeneruokite atsakymą naudodami LLM grandinę
response = llm_chain.run("Kas yra RAG?")

spausdinti (atsakymas)

Šiame pavyzdyje mes apibrėžiame LLM grandinę naudodami „LLMChain“ klasę iš „LangChain“. Tada mes naudojame „vykdymo“ metodą atsakymui generuoti naudodami LLM grandinę.

5–10 dažniausiai naudojamų komandų / fragmentų

Čia yra 5–10 dažniausiai naudojamų komandų / fragmentų, skirtų RAG diegti naudojant FastAPI ir Django:

1. „Iš langchain importo LLMChain“: importuokite „LLMChain“ klasę iš „LangChain“.
2. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", document=["doc1", "doc2", "doc3"]))): apibrėžkite LLM grandinę naudodami LLMChain klasę.
3. „Response = llm_chain.run(query)“: sugeneruokite atsakymą naudodami LLM grandinę.
4. „Iš fastapi import FastAPI“: importuokite „FastAPI“ klasę iš „FastAPI“.
5. „app = FastAPI()“: apibrėžkite FastAPI programą.
6. @app.get("/rag"): apibrėžkite RAG galinio taško maršrutą.
7. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", document=["doc1", "doc2", "doc3"]))): apibrėžkite LLM grandinę naudodami LLMChain klasę.
8. „Response = llm_chain.run(query)“: sugeneruokite atsakymą naudodami LLM grandinę.
9. „iš django.http importuoti JsonResponse“: importuokite „JsonResponse“ klasę iš „Django“.
10. return JsonResponse({"atsakymas": atsakymas}): grąžinkite JSON atsakymą su sugeneruotu atsakymu.

Vizualizacija

Štai RAG dujotiekio vizualizacija naudojant Chart.js:

{
  "type": "horizontalBar",
  "duomenys": {
    "etiketės": ["Gavimas", "Generavimas", "Polėtinis apdorojimas"],
    "duomenų rinkiniai": [
      {
        "etiketė": "RAG vamzdynas",
        "duomenys": [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
      }
    ]
  },
  "parinktys": {
    "pavadinimas": {
      "display": tiesa,
      "tekstas": "RAG vamzdynas"
    },
    "svarstyklės": {
      „yAxes“: [
        {
          "erkės": {
            "beginAtZero": tiesa
          }
        }
      ]
    }
  }
}

Ši vizualizacija rodo RAG dujotiekį su trimis etapais: gavimas, generavimas ir tolesnis apdorojimas.

Išvada

Šiame straipsnyje mes ištyrėme RAG metodų įgyvendinimą naudojant FastAPI ir Django, kad pagerintume LLM galimybes žiniatinklio programose, įskaitant orkestravimą su LangChain, kad būtų galima sklandžiai gauti ir apdoroti duomenis. Taip pat pateikėme praktinį RAG diegimo su FastAPI ir Django vadovą, įskaitant kodo pavyzdžius ir RAG dujotiekio vizualizaciją. Tikimės, kad šis straipsnis buvo naudingas šaltinis kūrėjams, norintiems įdiegti RAG metodus savo žiniatinklio programose.