ינטאַגרייטינג RAG (ריטריוואַל-אַוגמענטעד דור) מיט מאָדערן וועב פראַמעוואָרקס: אַ פּראַקטיש גייד

הקדמה

אין די לעצטע יאָרן, די פעלד פון נאַטירלעך שפּראַך פּראַסעסינג (NLP) האט וויטנאַסט אַ באַטייטיק סערדזש אין דער אַנטוויקלונג פון גרויס שפּראַך מאָדעלס (LLMs) און זייער אַפּלאַקיישאַנז אין פאַרשידן דאָומיינז. אָבער, איינער פון די הויפּט לימיטיישאַנז פון LLMs איז זייער ינאַביליטי צו צוריקקריגן און ינקאָרפּערייט פונדרויסנדיק וויסן אין זייער רעספּאָנסעס. דאָס איז ווו ריטריוואַל-אַוגמענטעד גענעראַטיאָן (RAG) טעקניקס קומען אין שפּיל. אין דעם אַרטיקל, מיר וועלן ויספאָרשן די ימפּלאַמענטיישאַן פון RAG טעקניקס ניצן FastAPI און Django צו פאַרבעסערן LLM קייפּאַבילאַטיז אין וועב אַפּלאַקיישאַנז, אַרייַנגערעכנט אָרקעסטראַטיאָן מיט LangChain פֿאַר סימלאַס דאַטן ריטריוואַל און פּראַסעסינג.

וואָס איז RAG?

RAG איז אַ טעכניק וואָס קאַמביינז די סטרענגקטס פון ריטריוואַל און דור מאָדעלס צו פּראָדוצירן מער פּינטלעך און ינפאָרמאַטיוו רעספּאָנסעס. די גרונט געדאַנק הינטער RAG איז צו ערשטער צוריקקריגן באַטייַטיק אינפֿאָרמאַציע פון ​​אַ וויסן באַזע אָדער אַ דאַטאַבייס, און דערנאָך נוצן די אינפֿאָרמאַציע צו דזשענערייט אַ ענטפער. דער צוגאַנג אַלאַוז LLMs צו לעווערידזש פונדרויסנדיק וויסן און צושטעלן מער פּינטלעך און ינפאָרמאַטיוו רעספּאָנסעס.

** פארוואס נוצן RAG מיט FastAPI און Django?**

FastAPI און Django זענען צוויי פון די מערסט פאָלקס וועב פראַמעוואָרקס געניצט פֿאַר בנין וועב אַפּלאַקיישאַנז. זיי צושטעלן אַ שטאַרק און סקאַלאַבלע ינפראַסטראַקטשער פֿאַר בנין וועב אַפּלאַקיישאַנז, און קענען זיין לייכט ינאַגרייטיד מיט RAG טעקניקס צו פֿאַרבעסערן LLM קייפּאַבילאַטיז. FastAPI איז אַ מאָדערן וועב פריימווערק וואָס גיט אַ שנעל און עפעקטיוו וועג צו בויען וועב אַפּלאַקיישאַנז, בשעת Django איז אַ הויך-מדרגה וועב פריימווערק וואָס גיט אַן אַרקאַטעקטשער, טעמפּלאַטעס און אַפּיס פֿאַר בנין געזונט וועב אַפּלאַקיישאַנז.

** ימפּלאַמענטינג RAG מיט FastAPI**

FastAPI גיט אַ פּשוט און עפעקטיוו וועג צו ינסטרומענט RAG טעקניקס. דאָ איז אַ ביישפּיל קאָד בלאָק וואָס דעמאַנסטרייץ ווי צו נוצן FastAPI צו ינסטרומענט RAG:

פֿון fastapi אַרייַנפיר FastAPI
פֿון לאַנגטשאַין אַרייַנפיר LLMChain
פֿון langchain.chains.openai אַרייַנפיר אָפּענאַיאַפּי

אַפּ = FastAPI()

@app.get ("/ שמאַטע")
async def rag (אָנפֿרעג: str):
    
    llm_chain = LLMChain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            index=LangChainIndex(
                נאָמען = "מיין_ינדעקס",
                דאָקומענטן=["דאָק1", "דאָק2", "דאָק3"]
            )
        )
    )

    # דזשענערייט אַ ענטפער מיט די LLM קייט
    ענטפער = llm_chain.run (אָנפֿרעג)

    צוריקקומען {"ענטפער": ענטפער}

אין דעם בייַשפּיל, מיר דעפינירן אַ LLM קייט מיט די 'LLMCain' קלאַס פֿון LangChain. דערנאָך מיר דעפינירן אַ ריטריוואַל קאָמפּאָנענט ניצן די קלאַס LangChainRetrieval, וואָס איז געניצט צו צוריקקריגן באַטייַטיק אינפֿאָרמאַציע פֿון אַ וויסן באַזע אָדער אַ דאַטאַבייס. צום סוף, מיר נוצן די 'לויפן' אופֿן צו דזשענערייט אַ ענטפער מיט די LLM קייט.

** ימפּלאַמענטינג RAG מיט Django**

Django גיט אַ הויך-מדרגה וועב פריימווערק וואָס קענען זיין לייכט ינאַגרייטיד מיט RAG טעקניקס. דאָ איז אַ ביישפּיל קאָד בלאָק וואָס דעמאַנסטרייץ ווי צו נוצן Django צו ינסטרומענט RAG:

פֿון django.http אַרייַנפיר JsonResponse
פֿון לאַנגטשאַין אַרייַנפיר LLMChain
פֿון langchain.chains.openai אַרייַנפיר אָפּענאַיאַפּי

דעף שמאַטע (רעקוועסט):
    # דעפינירן די LLM קייט
    llm_chain = LLMChain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            index=LangChainIndex(
                נאָמען = "מיין_ינדעקס",
                דאָקומענטן=["דאָק1", "דאָק2", "דאָק3"]
            )
        )
    )

    # דזשענערייט אַ ענטפער מיט די LLM קייט
    ענטפער = llm_chain.run(request.GET.get("אָנפֿרעג"))

    return JsonResponse({"response": response})

אין דעם ביישפּיל, מיר דעפינירן אַ מיינונג פֿונקציע שמאַטע וואָס נעמט אַ אָנפֿרעג ווי אַרייַנשרייַב און דזשענערייץ אַ ענטפער ניצן די LLM קייט.

אָרקעסטרייטינג RAG מיט LangChain

LangChain גיט אַ פּשוט און עפעקטיוו וועג צו אָרקעסטרירן RAG טעקניקס. דאָ איז אַ ביישפּיל קאָד בלאָק וואָס דעמאַנסטרייץ ווי צו נוצן LangChain צו אָרקעסטרירן RAG:

פֿון לאַנגטשאַין אַרייַנפיר LLMChain
פֿון langchain.chains.openai אַרייַנפיר אָפּענאַיאַפּי

# דעפינירן די LLM קייט
llm_chain = LLMChain(
    llm=OpenAIApi(),
    retrieval=LangChainRetrieval(
        index=LangChainIndex(
            נאָמען = "מיין_ינדעקס",
            דאָקומענטן=["דאָק1", "דאָק2", "דאָק3"]
        )
    )
)

# דזשענערייט אַ ענטפער מיט די LLM קייט
ענטפער = llm_chain.run ("וואָס איז RAG?")

דרוק (ענטפער)

אין דעם בייַשפּיל, מיר דעפינירן אַ LLM קייט מיט די 'LLMCain' קלאַס פֿון LangChain. דערנאָך מיר נוצן די 'לויפן' אופֿן צו דזשענערייט אַ ענטפער מיט די LLM קייט.

שפּיץ 5-10 מערסט געוויינט קאַמאַנדז / סניפּאַץ

דאָ זענען די שפּיץ 5-10 מערסט געוויינט קאַמאַנדז / סניפּאַץ פֿאַר ימפּלאַמענינג RAG מיט FastAPI און Django:

1. פֿון לאַנגטשאַין אַרייַנפיר LLMChain: ימפּאָרט די LLMCain קלאַס פֿון LangChain.
2. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"]))): דעפינירן אַ LLM קייט ניצן די LLMChain קלאַס.
3. response = llm_chain.run(קווערי): דזשענערייט אַ ענטפער ניצן די LLM קייט.
4. פֿון פאַסטאַפּי אַרייַנפיר FastAPI: ימפּאָרט די FastAPI קלאַס פֿון FastAPI.
5. אַפּ = FastAPI(): דעפינירן אַ FastAPI אַפּלאַקיישאַן.
6. @app.get("/rag"): דעפינירן אַ מאַרשרוט פֿאַר די RAG ענדפּוינט.
7. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"]))): דעפינירן אַ LLM קייט ניצן די LLMChain קלאַס.
8. response = llm_chain.run(קווערי): דזשענערייט אַ ענטפער ניצן די LLM קייט.
9. פֿון django.http אַרייַנפיר JsonResponse: ימפּאָרט די 'JsonResponse' קלאַס פֿון Django.
10. return JsonResponse({"response": response}): צוריקקומען אַ JSON ענטפער מיט די דזשענערייטאַד ענטפער.

וויסואַליזאַטיאָן

דאָ איז אַ וויזשוואַלאַזיישאַן פון די RAG רערנ - ליניע ניצן Chart.js:

{
  "type": "האָריזאָנטאַל באַר",
  "דאַטן": {
    "labels": ["ריטריוואַל", "דור", "נאָך-פּראַסעסינג"],
    "דאַטאַסעטס": [
      {
        "label": "RAG רערנ - ליניע",
        "דאַטן": [10, 20, 30],
        "backgroundColor": [
          "rgba(255, 99, 132, 0.2)",
          "rgba(54, 162, 235, 0.2)",
          "רגבאַ(255, 206, 86, 0.2)"
        ],
        "borderColor": [
          "rgba(255, 99, 132, 1)",
          "rgba(54, 162, 235, 1)",
          "רגבאַ(255, 206, 86, 1)"
        ],
        "באָרדערווידטה": 1
      }
    ]
  },
  "אָפּציעס": {
    "טיטל": {
      "ווייַז": אמת,
      "text": "שוואַרץ פּייפּליין"
    },
    "סקאַלעס": {
      "יאַקסעס": [
        {
          "טיקס": {
            "באַגינאַט זעראָ": אמת
          }
        }
      ]
    }
  }
}

די וויזשוואַלאַזיישאַן ווייזט די RAG רערנ - ליניע מיט דריי סטאַגעס: ריטריוואַל, דור און נאָך פּראַסעסינג.

** מסקנא**

אין דעם אַרטיקל, מיר ויספאָרשן די ימפּלאַמענטיישאַן פון RAG טעקניקס ניצן FastAPI און Django צו פאַרבעסערן LLM קייפּאַבילאַטיז אין וועב אַפּלאַקיישאַנז, אַרייַנגערעכנט אָרקעסטראַטיאָן מיט LangChain פֿאַר סימלאַס דאַטן ריטריוואַל און פּראַסעסינג. מיר אויך צוגעשטעלט אַ פּראַקטיש פירער צו ימפּלאַמענינג RAG מיט FastAPI און Django, אַרייַנגערעכנט קאָד ביישפילן און אַ וויזשוואַלאַזיישאַן פון די RAG רערנ - ליניע. מיר האָפן אַז דער אַרטיקל האט צוגעשטעלט אַ נוציק מיטל פֿאַר דעוועלאָפּערס וואָס זוכן צו ינסטרומענט RAG טעקניקס אין זייער וועב אַפּלאַקיישאַנז.