RAG'yi (Geri Alma-Artırılmış Üretim) Modern Web Çerçeveleriyle Bütünleştirme: Pratik Bir Kılavuz

Giriş

Son yıllarda Doğal Dil İşleme (NLP) alanı, Büyük Dil Modellerinin (LLM) geliştirilmesinde ve bunların çeşitli alanlardaki uygulamalarında önemli bir artışa tanık oldu. Bununla birlikte, Yüksek Lisans'ların en büyük sınırlamalarından biri, dış bilgileri geri getirip yanıtlarına dahil edememeleridir. Alma-Artırılmış Üretim (RAG) tekniklerinin devreye girdiği yer burasıdır. Bu makalede, kesintisiz veri alımı ve işleme için LangChain ile orkestrasyon da dahil olmak üzere web uygulamalarındaki LLM yeteneklerini geliştirmek için FastAPI ve Django kullanarak RAG tekniklerinin uygulanmasını inceleyeceğiz.

RAG nedir?

RAG, daha doğru ve bilgilendirici yanıtlar üretmek için Alma ve Oluşturma modellerinin güçlü yönlerini birleştiren bir tekniktir. RAG'ın arkasındaki temel fikir, öncelikle ilgili bilgiyi bir bilgi tabanından veya veri tabanından almak ve daha sonra bu bilgiyi bir yanıt oluşturmak için kullanmaktır. Bu yaklaşım, LLM'lerin dış bilgilerden yararlanmasına ve daha doğru ve bilgilendirici yanıtlar sağlamasına olanak tanır.

Neden FastAPI ve Django ile RAG Kullanılmalı?

FastAPI ve Django, web uygulamaları oluşturmak için kullanılan en popüler web çerçevelerinden ikisidir. Web uygulamaları oluşturmak için sağlam ve ölçeklenebilir bir altyapı sağlarlar ve LLM yeteneklerini geliştirmek için RAG teknikleriyle kolayca entegre edilebilirler. FastAPI, web uygulamaları oluşturmanın hızlı ve etkili bir yolunu sağlayan modern bir web çerçevesidir; Django ise sağlam web uygulamaları oluşturmaya yönelik bir mimari, şablonlar ve API'ler sağlayan üst düzey bir web çerçevesidir.

FastAPI ile RAG'ın uygulanması

FastAPI, RAG tekniklerini uygulamak için basit ve etkili bir yol sağlar. RAG'ı uygulamak için FastAPI'nin nasıl kullanılacağını gösteren örnek bir kod bloğunu burada bulabilirsiniz:

fastapi'den FastAPI'yi içe aktar
langchain'den LLMChain'i içe aktarın
langchain.chains.openai'den OpenAIApi'yi içe aktarın

uygulama = FastAPI()

@app.get("/rag")
async def rag(sorgu: str):
    
    llm_chain = LLMChain(
        llm=OpenAIApi(),
        alma=LangChainRetrieval(
            index=LangChainIndex(
                name = "my_index",
                belgeler=["belge1", "belge2", "belge3"]
            )
        )
    )

    # LLM zincirini kullanarak bir yanıt oluşturun
    yanıt = llm_chain.run(sorgu)

    dönüş {"yanıt": yanıt}
''''

Bu örnekte, LangChain'in 'LLMCain' sınıfını kullanarak bir LLM zinciri tanımlıyoruz. Daha sonra, bir bilgi tabanından veya veritabanından ilgili bilgiyi almak için kullanılan 'LangChainRetrieval' sınıfını kullanarak bir alma bileşeni tanımlarız. Son olarak LLM zincirini kullanarak bir yanıt oluşturmak için 'run' yöntemini kullanıyoruz.

**Django ile RAG'ı uygulama**


Django, RAG teknikleriyle kolayca entegre edilebilecek üst düzey bir web çerçevesi sağlar. RAG'ı uygulamak için Django'nun nasıl kullanılacağını gösteren örnek bir kod bloğu burada verilmiştir:

```piton
django.http'den JsonResponse'u içe aktarın
langchain'den LLMChain'i içe aktarın
langchain.chains.openai'den OpenAIApi'yi içe aktarın

def paçavra (istek):
    # LLM zincirini tanımlayın
    llm_chain = LLMChain(
        llm=OpenAIApi(),
        alma=LangChainRetrieval(
            index=LangChainIndex(
                name = "my_index",
                belgeler=["belge1", "belge2", "belge3"]
            )
        )
    )

    # LLM zincirini kullanarak bir yanıt oluşturun
    yanıt = llm_chain.run(request.GET.get("sorgu"))

    return JsonResponse({"yanıt": yanıt})
''''

Bu örnekte, bir sorguyu girdi olarak alan ve LLM zincirini kullanarak bir yanıt üreten bir görünüm fonksiyonu "rag" tanımlıyoruz.

**LangChain ile RAG'yi düzenleme**


LangChain, RAG tekniklerini düzenlemek için basit ve etkili bir yol sağlar. RAG'ı düzenlemek için LangChain'in nasıl kullanılacağını gösteren örnek bir kod bloğu burada verilmiştir:

```piton
langchain'den LLMChain'i içe aktarın
langchain.chains.openai'den OpenAIApi'yi içe aktarın

# LLM zincirini tanımlayın
llm_chain = LLMChain(
    llm=OpenAIApi(),
    alma=LangChainRetrieval(
        index=LangChainIndex(
            name = "my_index",
            belgeler=["belge1", "belge2", "belge3"]
        )
    )
)

# LLM zincirini kullanarak bir yanıt oluşturun
yanıt = llm_chain.run("RAG nedir?")

yazdır(yanıt)
''''

Bu örnekte, LangChain'in 'LLMCain' sınıfını kullanarak bir LLM zinciri tanımlıyoruz. Daha sonra LLM zincirini kullanarak bir yanıt oluşturmak için 'run' yöntemini kullanırız.

**En Çok Kullanılan 5-10 Komut/Parçacık**


RAG'ı FastAPI ve Django ile uygulamak için en çok kullanılan 5-10 komut/parçacık şunlardır:

1. `langchain'den LLMChain'i içe aktarın: LangChain'den `LLMChain' sınıfını içe aktarın.
2. `llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name=index", document=["doc1", "doc2", "doc3"])))`: `LLMChain' sınıfını kullanarak bir LLM zinciri tanımlayın.
3. `response = llm_chain.run(query)`: LLM zincirini kullanarak bir yanıt oluşturun.
4. `fastapi'den FastAPI'yi içe aktarın`: FastAPI'den `FastAPI` sınıfını içe aktarın.
5. `app = FastAPI()`: Bir FastAPI uygulaması tanımlayın.
6. `@app.get("/rag")`: RAG uç noktası için bir rota tanımlayın.
7. `llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", document=["doc1", "doc2", "doc3"]))): "LLMChain" sınıfını kullanarak bir LLM zinciri tanımlayın.
8. `response = llm_chain.run(query)`: LLM zincirini kullanarak bir yanıt oluşturun.
9. `django.http'den JsonResponse'u içe aktarın': Django'dan `JsonResponse' sınıfını içe aktarın.
10. `return JsonResponse({"response": Response})`: Oluşturulan yanıtla birlikte bir JSON yanıtı döndürün.

**Görselleştirme**


Aşağıda, Chart.js kullanılarak RAG ardışık düzeninin görselleştirilmesi verilmiştir:

```json
{
  "type": "horizontalBar",
  "veri": {
    "etiketler": ["Geri Alma", "Oluşturma", "Son İşleme"],
    "veri kümeleri": [
      {
        "label": "RAG Boru Hattı",
        "veri": [10, 20, 30],
        "arkaplanRengi": [
          "rgba(255, 99, 132, 0,2)",
          "rgba(54, 162, 235, 0,2)",
          "rgba(255, 206, 86, 0,2)"
        ],
        "kenar rengi": [
          "rgba(255, 99, 132, 1)",
          "rgba(54, 162, 235, 1)",
          "rgba(255, 206, 86, 1)"
        ],
        "kenar genişliği": 1
      }
    ]
  },
  "seçenekler": {
    "başlık": {
      "ekran": doğru,
      "text": "RAG Boru Hattı"
    },
    "ölçekler": {
      "yAxes": [
        {
          "keneler": {
            "beginAtZero": doğru
          }
        }
      ]
    }
  }
}
''''

Bu görselleştirme RAG ardışık düzenini üç aşamalı olarak göstermektedir: alma, oluşturma ve son işleme.

**Sonuç**


Bu makalede, kesintisiz veri alımı ve işleme için LangChain ile orkestrasyon da dahil olmak üzere web uygulamalarındaki LLM yeteneklerini geliştirmek için FastAPI ve Django kullanarak RAG tekniklerinin uygulanmasını araştırdık. Ayrıca, kod örnekleri ve RAG ardışık düzeninin görselleştirilmesi de dahil olmak üzere, FastAPI ve Django ile RAG'yi uygulamaya yönelik pratik bir kılavuz da sağladık. Bu makalenin, RAG tekniklerini web uygulamalarında uygulamak isteyen geliştiriciler için yararlı bir kaynak sağladığını umuyoruz.