Integracja RAG (generacja rozszerzona o pobieranie) z nowoczesnymi frameworkami sieciowymi: praktyczny przewodnik

Wprowadzenie

W ostatnich latach w dziedzinie przetwarzania języka naturalnego (NLP) nastąpił znaczny wzrost rozwoju dużych modeli językowych (LLM) i ich zastosowań w różnych dziedzinach. Jednak jednym z głównych ograniczeń LLM jest ich niezdolność do odzyskania i włączenia wiedzy zewnętrznej do swoich odpowiedzi. W tym miejscu wchodzą w grę techniki generowania wspomaganego odzyskiwania (RAG). W tym artykule przyjrzymy się implementacji technik RAG przy użyciu FastAPI i Django w celu zwiększenia możliwości LLM w aplikacjach internetowych, w tym orkiestracji za pomocą LangChain w celu płynnego pobierania i przetwarzania danych.

Co to jest RAG?

RAG to technika, która łączy zalety modeli wyszukiwania i generowania w celu uzyskania dokładniejszych i bardziej informacyjnych odpowiedzi. Podstawową ideą RAG jest najpierw pobranie odpowiednich informacji z bazy wiedzy lub bazy danych, a następnie wykorzystanie tych informacji do wygenerowania odpowiedzi. Takie podejście pozwala LLM wykorzystać wiedzę zewnętrzną i zapewnić dokładniejsze i bardziej informacyjne odpowiedzi.

Dlaczego warto używać RAG z FastAPI i Django?

FastAPI i Django to dwa najpopularniejsze frameworki internetowe używane do tworzenia aplikacji internetowych. Zapewniają solidną i skalowalną infrastrukturę do tworzenia aplikacji internetowych i można je łatwo zintegrować z technikami RAG w celu zwiększenia możliwości LLM. FastAPI to nowoczesna platforma internetowa, która zapewnia szybki i wydajny sposób tworzenia aplikacji internetowych, natomiast Django to platforma internetowa wysokiego poziomu, która zapewnia architekturę, szablony i interfejsy API do tworzenia niezawodnych aplikacji internetowych.

Wdrażanie RAG z FastAPI

FastAPI zapewnia prosty i skuteczny sposób wdrażania technik RAG. Oto przykładowy blok kodu demonstrujący, jak używać FastAPI do implementacji RAG:

z fastapi import FastAPI
z langchain import LLMCain
z langchain.chains.openai importuje OpenAIApi

aplikacja = FastAPI()

@app.get("/rag")
async def rag (zapytanie: str):
    
    llm_chain = LLMCain(
        llm=OpenAIApi(),
        pobieranie = pobieranie LangChain (
            indeks=LangChainIndex(
                nazwa="mój_indeks",
                dokumenty=["doc1", "doc2", "doc3"]
            )
        )
    )

    # Wygeneruj odpowiedź za pomocą łańcucha LLM
    odpowiedź = llm_chain.run(zapytanie)

    zwróć {"odpowiedź": odpowiedź}

W tym przykładzie definiujemy łańcuch LLM przy użyciu klasy LLMChain z LangChain. Następnie definiujemy komponent wyszukiwania za pomocą klasy „LangChainRetrieval”, która służy do pobierania odpowiednich informacji z bazy wiedzy lub bazy danych. Na koniec używamy metody „run”, aby wygenerować odpowiedź za pomocą łańcucha LLM.

Wdrażanie RAG z Django

Django zapewnia framework sieciowy wysokiego poziomu, który można łatwo zintegrować z technikami RAG. Oto przykładowy blok kodu demonstrujący, jak używać Django do implementacji RAG:

z django.http importuj JsonResponse
z langchain import LLMCain
z langchain.chains.openai importuje OpenAIApi

def rag(żądanie):
    # Zdefiniuj łańcuch LLM
    llm_chain = LLMCain(
        llm=OpenAIApi(),
        pobieranie = pobieranie LangChain (
            indeks=LangChainIndex(
                nazwa="mój_indeks",
                dokumenty=["doc1", "doc2", "doc3"]
            )
        )
    )

    # Wygeneruj odpowiedź za pomocą łańcucha LLM
    odpowiedź = llm_chain.run(request.GET.get("zapytanie"))

    return JsonResponse({"odpowiedź": odpowiedź})

W tym przykładzie definiujemy funkcję widoku „rag”, która przyjmuje zapytanie jako dane wejściowe i generuje odpowiedź za pomocą łańcucha LLM.

Orkiestrowanie RAG za pomocą LangChain

LangChain zapewnia prosty i skuteczny sposób koordynowania technik RAG. Oto przykładowy blok kodu demonstrujący, jak używać LangChain do orkiestracji RAG:

z langchain import LLMChain
z langchain.chains.openai importuje OpenAIApi

# Zdefiniuj łańcuch LLM
llm_chain = LLMCain(
    llm=OpenAIApi(),
    pobieranie = pobieranie LangChain (
        indeks=LangChainIndex(
            nazwa="mój_indeks",
            dokumenty=["doc1", "doc2", "doc3"]
        )
    )
)

# Wygeneruj odpowiedź za pomocą łańcucha LLM
odpowiedź = llm_chain.run("Co to jest RAG?")

wydrukuj (odpowiedź)

W tym przykładzie definiujemy łańcuch LLM przy użyciu klasy LLMChain z LangChain. Następnie używamy metody „run”, aby wygenerować odpowiedź za pomocą łańcucha LLM.

Top 5-10 najczęściej używanych poleceń/fragmentów

Oto 5-10 najczęściej używanych poleceń/fragmentów do implementacji RAG z FastAPI i Django:

1. z langchain import LLMChain: Importuj klasę LLMChain z LangChain.
2. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", dokumenty=["doc1", "doc2", "doc3"]))): Zdefiniuj łańcuch LLM przy użyciu klasy LLMChain.
3. response = llm_chain.run(query): Wygeneruj odpowiedź za pomocą łańcucha LLM.
4. z fastapi import FastAPI: Zaimportuj klasę FastAPI z FastAPI.
5. app = FastAPI(): Zdefiniuj aplikację FastAPI.
6. @app.get("/rag"): Zdefiniuj trasę dla punktu końcowego RAG.
7. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", dokumenty=["doc1", "doc2", "doc3"]))): Zdefiniuj łańcuch LLM przy użyciu klasy LLMChain.
8. response = llm_chain.run(query): Wygeneruj odpowiedź za pomocą łańcucha LLM.
9. from django.http import JsonResponse: Importuj klasę JsonResponse z Django.
10. return JsonResponse({"odpowiedź": odpowiedź}): Zwraca odpowiedź JSON z wygenerowaną odpowiedzią.

Wizualizacja

Oto wizualizacja rurociągu RAG przy użyciu Chart.js:

{
  "type": "horizontalBar",
  „dane”: {
    „etykiety”: [„Pobieranie”, „Generowanie”, „Przetwarzanie końcowe”],
    „zestawy danych”: [
      {
        "label": "Rurociąg RAG",
        „dane”: [10, 20, 30],
        „Kolor tła”: [
          "rgba(255, 99, 132, 0,2)",
          "rgba(54, 162, 235, 0,2)",
          „rgba(255, 206, 86, 0,2)”
        ],
        „kolor obramowania”: [
          "rgba(255, 99, 132, 1)",
          "rgba(54, 162, 235, 1)",
          „rgba(255, 206, 86, 1)”
        ],
        „Szerokość obramowania”: 1
      }
    ]
  },
  „opcje”: {
    "tytuł": {
      "wyświetlacz": prawda,
      "text": "Rurociąg RAG"
    },
    „skale”: {
      „Osie y”: [
        {
          „tyknięcia”: {
            „beginAtZero”: prawda
          }
        }
      ]
    }
  }
}

Ta wizualizacja przedstawia rurociąg RAG z trzema etapami: pobieraniem, generowaniem i przetwarzaniem końcowym.

Wniosek

W tym artykule zbadaliśmy wdrożenie technik RAG przy użyciu FastAPI i Django w celu zwiększenia możliwości LLM w aplikacjach internetowych, w tym orkiestracji za pomocą LangChain w celu bezproblemowego pobierania i przetwarzania danych. Udostępniliśmy także praktyczny przewodnik dotyczący wdrażania RAG z FastAPI i Django, zawierający przykłady kodu i wizualizację potoku RAG. Mamy nadzieję, że ten artykuł stanowi przydatne źródło informacji dla programistów chcących wdrożyć techniki RAG w swoich aplikacjach internetowych.