A RAG (Retrieval-Augmented Generation) integrálása modern webes keretrendszerekkel: gyakorlati útmutató

Bevezetés

Az elmúlt években a természetes nyelvi feldolgozás (NLP) területén jelentős felfutás tapasztalható a nagy nyelvi modellek (LLM) és alkalmazásaik terén a különböző területeken. Az LLM-ek egyik fő korlátja azonban az, hogy képtelenek visszakeresni és válaszaikba beépíteni a külső tudást. Itt lépnek életbe a Retrieval-Augmented Generation (RAG) technikák. Ebben a cikkben megvizsgáljuk a RAG technikák FastAPI és Django segítségével történő megvalósítását az LLM képességek fejlesztése érdekében a webalkalmazásokban, beleértve a LangChain hangszerelést a zökkenőmentes adatvisszakeresés és -feldolgozás érdekében.

Mi az a RAG?

A RAG egy olyan technika, amely egyesíti a Retrieval és Generation modellek erősségeit, hogy pontosabb és informatívabb válaszokat adjon. A RAG mögött meghúzódó alapötlet az, hogy először egy tudásbázisból vagy adatbázisból kell lekérni a releváns információkat, majd ezt az információt felhasználni válasz generálására. Ez a megközelítés lehetővé teszi az LLM-ek számára, hogy kihasználják a külső tudást, és pontosabb és informatívabb válaszokat adjanak.

Miért érdemes RAG-ot használni a FastAPI-val és a Django-val?

A FastAPI és a Django a webalkalmazások készítésére használt két legnépszerűbb webes keretrendszer. Robusztus és méretezhető infrastruktúrát biztosítanak a webalkalmazások készítéséhez, és könnyen integrálhatók a RAG technikákkal az LLM képességek javítása érdekében. A FastAPI egy modern webes keretrendszer, amely gyors és hatékony módot biztosít webes alkalmazások létrehozására, míg a Django egy magas szintű webes keretrendszer, amely architektúrát, sablonokat és API-kat biztosít robusztus webalkalmazások készítéséhez.

RAG megvalósítása FastAPI-val

A FastAPI egyszerű és hatékony módot biztosít a RAG technikák megvalósítására. Íme egy példa kódblokk, amely bemutatja, hogyan kell a FastAPI-t használni a RAG megvalósításához:

a fastapi importból FastAPI
a langchain importból LLMChain
a langchain.chains.openai webhelyről importálja az OpenAIApi-t

alkalmazás = FastAPI()

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

    # Hozzon létre választ az LLM lánc segítségével
    válasz = llm_chain.run(query)

    return {"válasz": válasz}

Ebben a példában egy LLM-láncot határozunk meg a LangChain LLMChain osztályával. Ezután a LangChainRetrieval osztály segítségével meghatározunk egy visszakeresési komponenst, amely a releváns információk lekérésére szolgál egy tudásbázisból vagy adatbázisból. Végül a "run" metódussal választ generálunk az LLM-lánc segítségével.

A RAG megvalósítása a Django segítségével

A Django magas szintű webes keretrendszert biztosít, amely könnyen integrálható a RAG technikákkal. Íme egy példa kódblokk, amely bemutatja, hogyan kell használni a Django-t a RAG megvalósításához:

a django.http importból JsonResponse
a langchain importból LLMChain
a langchain.chains.openai webhelyről importálja az OpenAIApi-t

def rag (kérés):
    # Határozza meg az LLM láncot
    llm_chain = LLMChain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            index=LangChainIndex(
                name="my_index",
                document=["doc1", "doc2", "doc3"]
            )
        )
    )

    # Hozzon létre választ az LLM lánc segítségével
    válasz = llm_chain.run(request.GET.get("query"))

    return JsonResponse({"válasz": válasz})

Ebben a példában definiálunk egy 'rag' nézetfüggvényt, amely egy lekérdezést vesz bemenetként, és választ generál az LLM-lánc segítségével.

RAG hangszerelése a LangChain segítségével

A LangChain egyszerű és hatékony módot kínál a RAG technikák hangszerelésére. Íme egy példa kódblokk, amely bemutatja, hogyan kell használni a LangChaint a RAG hangszereléséhez:

a langchain importból LLMChain
a langchain.chains.openai webhelyről importálja az OpenAIApi-t

# Határozza meg az LLM láncot
llm_chain = LLMchain(
    llm=OpenAIApi(),
    retrieval=LangChainRetrieval(
        index=LangChainIndex(
            name="my_index",
            document=["doc1", "doc2", "doc3"]
        )
    )
)

# Hozzon létre választ az LLM lánc segítségével
response = llm_chain.run("Mi az a RAG?")

nyomtatás (válasz)

Ebben a példában egy LLM-láncot határozunk meg a LangChain LLMChain osztályával. Ezután a "run" metódussal választ generálunk az LLM-lánc segítségével.

Az 5-10 leggyakrabban használt parancs/részlet

Íme az 5-10 leggyakrabban használt parancs/részlet a RAG FastAPI-val és Django-val való megvalósításához:

1. from langchain import LLMChain: Importálja az LLMChain osztályt a LangChainből.
2. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", document=["doc1", "doc2", "doc3"]))): LLM lánc definiálása az LLMChain osztály használatával.
3. response = llm_chain.run(query): Válasz generálása az LLM-lánc használatával.
4. FastAPI importból FastAPI: Importálja a FastAPI osztályt a FastAPI-ból.
5. app = FastAPI(): FastAPI alkalmazás meghatározása.
6. @app.get("/rag"): Határozzon meg egy útvonalat a RAG végponthoz.
7. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", document=["doc1", "doc2", "doc3"]))): LLM lánc definiálása az LLMChain osztály használatával.
8. response = llm_chain.run(query): Válasz generálása az LLM-lánc használatával.
9. from django.http import JsonResponse: A JsonResponse osztály importálása a Django-ból.
10. return JsonResponse({"response": response}): JSON-választ ad vissza a generált válasszal.

Vizualizáció

Íme a RAG-folyamat ábrázolása a Chart.js használatával:

{
  "type": "horizontalBar",
  "adat": {
    "címkék": ["Letöltés", "Generáció", "Utófeldolgozás"],
    "adatkészletek": [
      {
        "label": "RAG Pipeline",
        "data": [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
      }
    ]
  },
  "opciók": {
    "cím": {
      "megjelenítés": igaz,
      "text": "RAG Pipeline"
    },
    "mérleg": {
      "yAxes": [
        {
          "kullancsok": {
            "beginAtZero": igaz
          }
        }
      ]
    }
  }
}

Ez a vizualizáció a RAG folyamatot három szakaszban mutatja be: visszakeresés, generálás és utófeldolgozás.

Következtetés

Ebben a cikkben a RAG technikák FastAPI és Django segítségével történő megvalósítását vizsgáltuk az LLM képességek webalkalmazásokban való fejlesztésére, beleértve a LangChain hangszerelést a zökkenőmentes adatvisszakeresés és -feldolgozás érdekében. Gyakorlati útmutatót is adtunk a RAG megvalósításához a FastAPI és a Django segítségével, beleértve a kódpéldákat és a RAG folyamat vizualizációját. Reméljük, hogy ez a cikk hasznos forrást nyújtott azoknak a fejlesztőknek, akik webalkalmazásaikban szeretnék RAG technikákat alkalmazni.