Integri RAG (Retrieval-Augmented Generation) kun Modernaj Retaj Kadroj: Praktika Gvidilo

Enkonduko

En la lastaj jaroj, la kampo de Natural Language Processing (NLP) atestis signifan pliiĝon en la evoluo de Grandaj Lingvaj Modeloj (LLM) kaj iliaj aplikoj en diversaj domajnoj. Tamen, unu el la plej gravaj limigoj de LLMoj estas ilia malkapablo preni kaj integrigi eksteran scion en iliaj respondoj. Ĉi tie eniras teknikoj de Retrieval-Augmented Generation (RAG). En ĉi tiu artikolo, ni esploros la efektivigon de RAG-teknikoj uzante FastAPI kaj Django por plibonigi LLM-kapablojn en TTT-aplikoj, inkluzive de instrumentado kun LangChain por senjunta rehavigo kaj prilaborado de datumoj.

Kio estas RAG?

RAG estas tekniko kiu kombinas la fortojn de Retrieval kaj Generation-modeloj por produkti pli precizajn kaj informajn respondojn. La baza ideo malantaŭ RAG estas unue preni koncernajn informojn de sciobazo aŭ datumbazo, kaj poste uzi ĉi tiujn informojn por generi respondon. Ĉi tiu aliro permesas al LLMs utiligi eksteran scion kaj disponigi pli precizajn kaj informajn respondojn.

Kial uzi RAG kun FastAPI kaj Django?

FastAPI kaj Django estas du el la plej popularaj retaj kadroj uzataj por konstrui retajn aplikojn. Ili provizas fortikan kaj skaleblan infrastrukturon por konstrui TTT-aplikaĵojn, kaj povas esti facile integritaj kun RAG-teknikoj por plibonigi LLM-kapablojn. FastAPI estas moderna interreta kadro, kiu provizas rapidan kaj efikan manieron konstrui TTT-aplikaĵojn, dum Django estas altnivela TTT-kadro, kiu provizas arkitekturon, ŝablonojn kaj APIojn por konstrui fortikan TTT-aplikaĵojn.

Efektivigo de RAG kun FastAPI

FastAPI disponigas simplan kaj efikan manieron efektivigi RAG-teknikojn. Jen ekzempla kodbloko, kiu montras kiel uzi FastAPI por efektivigi RAG:

el fastapi importo FastAPI
de langchain import LLMChain
el langchain.chains.openai importu OpenAIApi

app = FastAPI ()

@app.get ("/ĉifono")
nesinkrona def ĉifono (demando: str):
    
    llm_ĉeno = LLMĈeno(
        llm=OpenAIApi(),
        retrovo=LangChainRetrieval (
            indekso=LangChainIndex(
                nomo="mia_indekso",
                dokumentoj="doc1", "doc2", "doc3"]
            )
        )
    )

    # Generu respondon uzante la LLM-ĉenon
    respondo = llm_chain.run (demando)

    reveni {"response": respondo}

En ĉi tiu ekzemplo, ni difinas LLM-ĉenon uzante la klason "LLMCain" de LangChain. Ni tiam difinas rehavigan komponanton uzante la klason `LangChainRetrieval', kiu estas uzata por preni koncernajn informojn de sciobazo aŭ datumbazo. Fine, ni uzas la metodon "kuru" por generi respondon uzante la LLM-ĉenon.

Efektivigo de RAG kun Django

Django disponigas altnivelan retan kadron kiu povas esti facile integrita kun RAG-teknikoj. Jen ekzempla kodbloko, kiu montras kiel uzi Django por efektivigi RAG:

el django.http import JsonResponse
de langchain import LLMChain
el langchain.chains.openai importu OpenAIApi

def ĉifono (peto):
    # Difinu la LLM-ĉenon
    llm_ĉeno = LLMĈeno(
        llm=OpenAIApi(),
        retrovo=LangChainRetrieval (
            indekso=LangChainIndex(
                nomo="mia_indekso",
                dokumentoj="doc1", "doc2", "doc3"]
            )
        )
    )

    # Generu respondon uzante la LLM-ĉenon
    respondo = llm_chain.run (peto.GET.get ("demando"))

    resendu JsonResponse({"response": respondo})

En ĉi tiu ekzemplo, ni difinas rigardan funkcion "rag" kiu prenas demandon kiel enigaĵon kaj generas respondon uzante la LLM-ĉenon.

Orkestrante RAG kun LangChain

LangChain provizas simplan kaj efikan manieron reĝisori RAG-teknikojn. Jen ekzempla kodbloko, kiu montras kiel uzi LangChain por reĝisori RAG:

de langchain import LLMChain
el langchain.chains.openai importu OpenAIApi

# Difinu la LLM-ĉenon
llm_ĉeno = LLMĈeno(
    llm=OpenAIApi(),
    retrovo=LangChainRetrieval (
        indekso=LangChainIndex(
            nomo="mia_indekso",
            dokumentoj="doc1", "doc2", "doc3"]
        )
    )
)

# Generu respondon uzante la LLM-ĉenon
respondo = llm_chain.run ("Kio estas RAG?")

presi (respondo)

En ĉi tiu ekzemplo, ni difinas LLM-ĉenon uzante la klason "LLMCain" de LangChain. Ni tiam uzas la "kuru" metodon por generi respondon uzante la LLM-ĉenon.

Supro 5-10 Plej Uzitaj Komandoj/Fragmentoj

Jen la supraj 5-10 plej uzataj komandoj/fragmentoj por efektivigi RAG kun FastAPI kaj Django:

1. from langchain import LLMChain: Importu la klason LLMCain de LangChain.
2. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval (index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"]))): Difinu LLM-ĉenon uzante la klason LLMCain.
3. response = llm_chain.run(query): Generu respondon uzante la LLM-ĉenon.
4. de fastapi import FastAPI: Importu la klason FastAPI de FastAPI.
5. app = FastAPI(): Difinu FastAPI-aplikaĵon.
6. @app.get("/rag"): Difinu itineron por la RAG-finpunkto.
7. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval (index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"]))): Difinu LLM-ĉenon uzante la klason LLMCain.
8. response = llm_chain.run(query): Generu respondon uzante la LLM-ĉenon.
9. from django.http import JsonResponse: Importu la klason JsonResponse el Django.
10. return JsonResponse({"response": response}): Resendi JSON-respondon kun la generita respondo.

Vidigo

Jen bildigo de la RAG-dukto uzante Chart.js:

{
  "tipo": "horizontalBar",
  "datenoj": {
    "labels": ["Retrovo", "Generacio", "Post-traktado"],
    "datumaro": [
      {
        "label": "RAG Dukto",
        "datenoj": [10, 20, 30],
        "fonoKoloro": [
          "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
      }
    ]
  },
  "opcioj": {
    "titolo": {
      "montri": vera,
      "text": "RAG Dukto"
    },
    "skaloj": {
      "yAxes": [
        {
          "ticks": {
            "beginAtZero": vera
          }
        }
      ]
    }
  }
}

Ĉi tiu bildigo montras la RAG-dukton kun tri stadioj: rehavigo, generacio kaj post-prilaborado.

Konkludo

En ĉi tiu artikolo, ni esploris la efektivigon de RAG-teknikoj uzante FastAPI kaj Django por plibonigi LLM-kapablojn en TTT-aplikoj, inkluzive de instrumentado kun LangChain por senjunta rehavigo kaj prilaborado de datumoj. Ni ankaŭ disponigis praktikan gvidilon por efektivigi RAG kun FastAPI kaj Django, inkluzive de kodaj ekzemploj kaj bildigo de la RAG-dukto. Ni esperas, ke ĉi tiu artikolo provizis utilan rimedon por programistoj, kiuj volas efektivigi RAG-teknikojn en siaj retejoj.