Integració de RAG (Retrieval-Augmented Generation) amb marcs web moderns: una guia pràctica

Introducció

En els darrers anys, el camp del processament del llenguatge natural (PNL) ha estat testimoni d'un augment significatiu en el desenvolupament de grans models de llenguatge (LLM) i les seves aplicacions en diversos dominis. Tanmateix, una de les principals limitacions dels LLM és la seva incapacitat per recuperar i incorporar coneixements externs a les seves respostes. Aquí és on entren en joc les tècniques de Retrieval-Augmented Generation (RAG). En aquest article, explorarem la implementació de tècniques RAG mitjançant FastAPI i Django per millorar les capacitats de LLM en aplicacions web, inclosa l'orquestració amb LangChain per a la recuperació i el processament de dades sense problemes.

Què és RAG?

RAG és una tècnica que combina els punts forts dels models de recuperació i generació per produir respostes més precises i informatives. La idea bàsica darrere de RAG és recuperar primer la informació rellevant d'una base de coneixement o una base de dades, i després utilitzar aquesta informació per generar una resposta. Aquest enfocament permet als LLM aprofitar el coneixement extern i oferir respostes més precises i informatives.

Per què utilitzar RAG amb FastAPI i Django?

FastAPI i Django són dos dels marcs web més populars utilitzats per crear aplicacions web. Proporcionen una infraestructura robusta i escalable per crear aplicacions web i es poden integrar fàcilment amb tècniques RAG per millorar les capacitats de LLM. FastAPI és un marc web modern que proporciona una manera ràpida i eficient de crear aplicacions web, mentre que Django és un marc web d'alt nivell que proporciona una arquitectura, plantilles i API per crear aplicacions web robustes.

Implementació de RAG amb FastAPI

FastAPI proporciona una manera senzilla i eficient d'implementar tècniques RAG. Aquí hi ha un exemple de bloc de codi que demostra com utilitzar FastAPI per implementar RAG:

des de fastapi importar FastAPI
de langchain import LLMChain
des de langchain.chains.openai importar OpenAIApi

aplicació = FastAPI()

@app.get("/rag")
async def rag (consulta: str):
    
    llm_chain = LLMChain(
        llm=OpenAIApi(),
        recuperació=LangChainRetrieval(
            index=LangChainIndex(
                nom="el meu_índex",
                documents="doc1", "doc2", "doc3"]
            )
        )
    )

    # Genereu una resposta mitjançant la cadena LLM
    resposta = llm_chain.run (consulta)

    retornar {"response": resposta}

En aquest exemple, definim una cadena LLM utilitzant la classe LLMCain de LangChain. A continuació, definim un component de recuperació mitjançant la classe LangChainRetrieval, que s'utilitza per recuperar informació rellevant d'una base de coneixement o una base de dades. Finalment, utilitzem el mètode run per generar una resposta mitjançant la cadena LLM.

Implementant RAG amb Django

Django proporciona un marc web d'alt nivell que es pot integrar fàcilment amb tècniques RAG. Aquí hi ha un exemple de bloc de codi que demostra com utilitzar Django per implementar RAG:

des django.http importa JsonResponse
de langchain import LLMChain
des de langchain.chains.openai importar OpenAIApi

def rag (sol·licitud):
    # Definiu la cadena de LLM
    llm_chain = LLMChain(
        llm=OpenAIApi(),
        recuperació=LangChainRetrieval(
            index=LangChainIndex(
                nom="el meu_índex",
                documents="doc1", "doc2", "doc3"]
            )
        )
    )

    # Genereu una resposta mitjançant la cadena LLM
    resposta = llm_chain.run(request.GET.get("consulta"))

    retorna JsonResponse({"resposta": resposta})

En aquest exemple, definim una funció de vista rag que pren una consulta com a entrada i genera una resposta mitjançant la cadena LLM.

Orquestrant RAG amb LangChain

LangChain proporciona una manera senzilla i eficient d'orquestrar les tècniques RAG. Aquí teniu un exemple de bloc de codi que demostra com utilitzar LangChain per orquestrar RAG:

de langchain import LLMChain
des de langchain.chains.openai importar OpenAIApi

# Definiu la cadena de LLM
llm_chain = LLMChain(
    llm=OpenAIApi(),
    recuperació=LangChainRetrieval(
        index=LangChainIndex(
            nom="el meu_índex",
            documents="doc1", "doc2", "doc3"]
        )
    )
)

# Genereu una resposta mitjançant la cadena LLM
resposta = llm_chain.run ("Què és RAG?")

imprimir (resposta)

En aquest exemple, definim una cadena LLM utilitzant la classe LLMCain de LangChain. A continuació, utilitzem el mètode "executar" per generar una resposta mitjançant la cadena LLM.

Les 5-10 ordres/fragments més utilitzats

A continuació es mostren les 5-10 ordres/fragments més utilitzats per implementar RAG amb FastAPI i Django:

1. from langchain import LLMChain: importa la classe LLMChain de LangChain.
2. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"]))): defineix una cadena LLM utilitzant la classe LLMCain.
3. response = llm_chain.run(query): genera una resposta utilitzant la cadena LLM.
4. from fastapi import FastAPI: importa la classe FastAPI de FastAPI.
5. app = FastAPI(): defineix una aplicació FastAPI.
6. @app.get("/rag"): defineix una ruta per al punt final del RAG.
7. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"]))): defineix una cadena LLM utilitzant la classe LLMCain.
8. response = llm_chain.run(query): genera una resposta mitjançant la cadena LLM.
9. from django.http importa JsonResponse: importa la classe JsonResponse de Django.
10. return JsonResponse({"response": response}): retorna una resposta JSON amb la resposta generada.

Visualització

Aquí teniu una visualització del pipeline RAG amb Chart.js:

{
  "type": "HorizontalBar",
  "dades": {
    "labels": ["Recuperació", "Generació", "Posprocessament"],
    "conjunts de dades": [
      {
        "label": "RAG Pipeline",
        "dades": [10, 20, 30],
        "color de fons": [
          "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
      }
    ]
  },
  "opcions": {
    "títol": {
      "visualització": cert,
      "text": "Rag Pipeline"
    },
    "escales": {
      "yAxes": [
        {
          "ticks": {
            "beginAtZero": cert
          }
        }
      ]
    }
  }
}

Aquesta visualització mostra el pipeline RAG amb tres etapes: recuperació, generació i postprocessament.

Conclusió

En aquest article, hem explorat la implementació de tècniques RAG mitjançant FastAPI i Django per millorar les capacitats de LLM en aplicacions web, inclosa l'orquestració amb LangChain per a la recuperació i el processament de dades sense problemes. També vam proporcionar una guia pràctica per implementar RAG amb FastAPI i Django, incloent exemples de codi i una visualització del pipeline RAG. Esperem que aquest article hagi proporcionat un recurs útil per als desenvolupadors que busquen implementar tècniques RAG a les seves aplicacions web.