RAG:n (Retrieval-Augmented Generation) integrointi moderneihin verkkokehyksiin: Käytännön opas

Esittely

Natural Language Processing (NLP) -ala on viime vuosina kokenut merkittävän nousun suurten kielimallien (LLM) ja niiden sovellusten kehityksessä eri aloilla. Yksi LLM:ien suurimmista rajoituksista on kuitenkin heidän kyvyttömyys hakea ulkopuolista tietoa ja sisällyttää sitä vastauksiinsa. Tässä kohtaa RAG (Retrieval-Augmented Generation) -tekniikat tulevat peliin. Tässä artikkelissa tutkimme RAG-tekniikoiden käyttöönottoa FastAPI:n ja Djangon avulla LLM-ominaisuuksien parantamiseksi verkkosovelluksissa, mukaan lukien LangChain-orkestrointi saumattoman tiedonhaun ja käsittelyn mahdollistamiseksi.

Mikä on RAG?

RAG on tekniikka, joka yhdistää haku- ja generointimallien vahvuudet tuottaakseen tarkempia ja informatiivisempia vastauksia. RAG:n perusideana on hakea ensin asiaankuuluvat tiedot tietokannasta tai tietokannasta ja sitten käyttää näitä tietoja vastauksen luomiseen. Tämän lähestymistavan avulla LLM:t voivat hyödyntää ulkoista tietoa ja tarjota tarkempia ja informatiivisempia vastauksia.

Miksi käyttää RAG:ta FastAPI:n ja Djangon kanssa?

FastAPI ja Django ovat kaksi suosituinta verkkokehystä, joita käytetään verkkosovellusten rakentamiseen. Ne tarjoavat vankan ja skaalautuvan infrastruktuurin verkkosovellusten rakentamiseen, ja ne voidaan helposti integroida RAG-tekniikoihin LLM-ominaisuuksien parantamiseksi. FastAPI on moderni verkkokehys, joka tarjoaa nopean ja tehokkaan tavan rakentaa verkkosovelluksia, kun taas Django on korkean tason verkkokehys, joka tarjoaa arkkitehtuurin, malleja ja API:ita kestävien verkkosovellusten rakentamiseen.

RAG:n käyttöönotto FastAPI:lla

FastAPI tarjoaa yksinkertaisen ja tehokkaan tavan toteuttaa RAG-tekniikoita. Tässä on esimerkkikoodilohko, joka osoittaa, kuinka FastAPI:ta käytetään RAG:n toteuttamiseen:

fastapista tuonti FastAPI
langchain import LLMChainista
Tuo OpenAIApi osoitteesta langchain.chains.openai

sovellus = FastAPI()

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

    # Luo vastaus käyttämällä LLM-ketjua
    vastaus = llm_chain.run(query)

    return {"response": vastaus}

Tässä esimerkissä määrittelemme LLM-ketjun käyttämällä LangChainin LLMchain-luokkaa. Määrittelemme sitten hakukomponentin käyttämällä LangChainRetrieval-luokkaa, jota käytetään haettaessa oleellista tietoa tietokannasta tai tietokannasta. Lopuksi käytämme "run"-menetelmää vastauksen luomiseen LLM-ketjun avulla.

RAG:n käyttöönotto Djangon kanssa

Django tarjoaa korkean tason verkkokehyksen, joka voidaan helposti integroida RAG-tekniikoihin. Tässä on esimerkkikoodilohko, joka osoittaa, kuinka Djangoa käytetään RAG:n toteuttamiseen:

osoitteesta django.http tuonti JsonResponse
langchain import LLMChainista
Tuo OpenAIApi osoitteesta langchain.chains.openai

def rag (pyyntö):
    # Määrittele LLM-ketju
    llm_chain = LLMChain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            index=LangChainIndex(
                name="oma_indeksi",
                document=["doc1", "doc2", "doc3"]
            )
        )
    )

    # Luo vastaus käyttämällä LLM-ketjua
    vastaus = llm_chain.run(request.GET.get("kysely"))

    return JsonResponse({"vastaus": vastaus})

Tässä esimerkissä määritämme näkymäfunktion "rag", joka ottaa kyselyn syötteenä ja luo vastauksen käyttämällä LLM-ketjua.

** RAG:n orkestrointi LangChainilla**

LangChain tarjoaa yksinkertaisen ja tehokkaan tavan organisoida RAG-tekniikoita. Tässä on esimerkkikoodilohko, joka osoittaa, kuinka LangChainia käytetään RAG:n järjestämiseen:

langchain import LLMChainista
Tuo OpenAIApi osoitteesta langchain.chains.openai

# Määrittele LLM-ketju
llm_chain = LLMChain(
    llm=OpenAIApi(),
    retrieval=LangChainRetrieval(
        index=LangChainIndex(
            name="oma_indeksi",
            document=["doc1", "doc2", "doc3"]
        )
    )
)

# Luo vastaus käyttämällä LLM-ketjua
vastaus = llm_chain.run("Mikä on RAG?")

tulosta (vastaus)

Tässä esimerkissä määrittelemme LLM-ketjun käyttämällä LangChainin LLMchain-luokkaa. Käytämme sitten "run"-menetelmää vastauksen luomiseen käyttämällä LLM-ketjua.

5–10 eniten käytettyä komentoa/katkelmaa

Tässä on 5-10 eniten käytettyä komentoa/katkelmaa RAG:n toteuttamiseen FastAPI:n ja Djangon kanssa:

1. langchain import LLMChainista: Tuo LLMChain-luokka LangChainista.
2. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", document=["doc1", "doc2", "doc3"]))): Määritä LLM-ketju käyttämällä LLMchain-luokkaa.
3. response = llm_chain.run(query): Luo vastaus käyttämällä LLM-ketjua.
4. "FastAPI-tuonnista FastAPI": Tuo "FastAPI"-luokka FastAPI:sta.
5. app = FastAPI(): Määritä FastAPI-sovellus.
6. @app.get("/rag"): Määritä reitti RAG-päätepisteelle.
7. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", document=["doc1", "doc2", "doc3"]))): Määritä LLM-ketju käyttämällä LLMChain-luokkaa.
8. response = llm_chain.run(query): Luo vastaus käyttämällä LLM-ketjua.
9. from django.http import JsonResponse: Tuo JsonResponse-luokka Djangosta.
10. return JsonResponse({"response": response}): Palauta JSON-vastaus luodun vastauksen kanssa.

Visualisointi

Tässä on visualisointi RAG-putkistosta Chart.js:n avulla:

{
  "type": "horizontalBar",
  "data": {
    "labels": ["Hae", "Sukupolvi", "Jälkikäsittely"],
    "tietojoukot": [
      {
        "label": "RAG Pipeline",
        "data": [10, 20, 30],
        "taustaväri": [
          "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
      }
    ]
  },
  "vaihtoehdot": {
    "otsikko": {
      "näyttö": totta,
      "text": "RAG Pipeline"
    },
    "vaa'at": {
      "yAxes": [
        {
          "ticks": {
            "beginAtZero": totta
          }
        }
      ]
    }
  }
}

Tämä visualisointi näyttää RAG-putkilinjan kolmessa vaiheessa: haku, luonti ja jälkikäsittely.

Johtopäätös

Tässä artikkelissa tutkimme RAG-tekniikoiden käyttöönottoa FastAPI:n ja Djangon avulla LLM-ominaisuuksien parantamiseksi verkkosovelluksissa, mukaan lukien LangChain-orkestrointi saumattoman tiedonhaun ja käsittelyn mahdollistamiseksi. Annoimme myös käytännön oppaan RAG:n käyttöönottoon FastAPI:n ja Djangon kanssa, sisältäen koodiesimerkkejä ja visualisoinnin RAG-putkistosta. Toivomme, että tämä artikkeli on tarjonnut hyödyllisen resurssin kehittäjille, jotka haluavat ottaa RAG-tekniikoita käyttöön verkkosovelluksissaan.