מתאר מהיר
פוסט זה יציג:
כיצד להשתמש בסוכן כדי להחזיר פלט מובנה ב-LangChain
שיטה 1: שילוב של סוכן עם חנויות וקטור
שיטה 3: שימוש בסוכן עם Multi-Hop Vector Store
כיצד להשתמש בסוכן כדי להחזיר פלט מובנה ב-LangChain?
המפתח משתמש בסוכנים כדי לנתב בין מסדי הנתונים המכילים נתוני אימון עבור המודלים. לסוכן יש את השרטוט של התהליך המלא על ידי אחסון כל השלבים. לסוכן יש את הכלים לבצע את כל הפעילויות הללו כדי להשלים את התהליך. המשתמש יכול גם להשתמש בסוכן כדי לקבל נתונים ממאגרי נתונים שונים כדי להפוך את המודל למגוון.
כדי ללמוד את התהליך של שילוב סוכנים וחנויות וקטורים ב-LangChain, פשוט בצע את השלבים המפורטים:
שלב 1: התקנת מסגרות
ראשית, התקן את מודול LangChain והתלות שלו לשילוב הסוכנים וחנויות הווקטור:
pip להתקין langchain 
במדריך זה, אנו משתמשים במסד הנתונים Chroma שיכול לאחסן נתונים במיקומים או בטבלאות שונות:
pip להתקין chromadb 
כדי לקבל הבנה טובה יותר של הנתונים, פצל את הקבצים הגדולים לנתחים קטנים יותר באמצעות ה-tiktoken tokenizer:
pip להתקין tiktoken 
OpenAI הוא המודול שניתן להשתמש בו לבניית מודל השפה הגדול במסגרת LangChain:
pip להתקין openai 
שלב 2: OpenAI Environment
השלב הבא כאן הוא ל להקים את הסביבה באמצעות מפתח ה-API של OpenAI שניתן לחלץ מהחשבון הרשמי של OpenAI:
יְבוּא אתהיְבוּא getpass
אתה . בְּעֵרֶך [ 'OPENAI_API_KEY' ] = getpass . getpass ( 'מפתח API של OpenAI:' )
כעת, העלה את הנתונים מהמערכת המקומית לשיתוף הפעולה של Google כדי להשתמש בהם בעתיד:
מ גוגל. ET AL יְבוּא קבציםהועלה = קבצים. להעלות ( )
שלב 3: יצירת חנות וקטור
שלב זה מגדיר את הרכיב הראשון במשימה שלנו שהוא חנות וקטורית לאחסון הנתונים שהועלו. הגדרת חנויות הווקטור דורשת את הספריות שניתן לייבא מתלות שונות של ה-LangChain:
מ langchain. הטבעות . openai יְבוּא OpenAIEbeddings#Vector מאחסן תלות כדי לקבל את מסד הנתונים או הווקטור הנדרש
מ langchain. חנויות וקטורים יְבוּא Chroma
#מפצל טקסט משמש להמרת הטקסט הגדול לגושים קטנים יותר
מ langchain. text_splitter יְבוּא CharacterTextSplitter
מ langchain. llms יְבוּא OpenAI
מ langchain. טוען_מסמכים יְבוּא WebBaseLoader
מ langchain. שרשראות יְבוּא שליפהQA
llm = OpenAI ( טֶמפֶּרָטוּרָה = 0 )
שלב 4: הגדרת הנתיב
לאחר ייבוא הספריות, פשוט הגדר את הנתיב לגישה למאגרי הווקטור לפני אחסון הנתונים בהם:
מ pathlib יְבוּא נָתִיבחלקים_רלוונטיים = [ ]
ל ע ב נָתִיב ( '.' ) . מוּחלָט ( ) . חלקים :
חלקים_רלוונטיים. לְצַרֵף ( ע )
אם חלקים_רלוונטיים [ - 3 : ] == [ 'langchain' , 'מסמכים' , 'מודולים' ] :
לשבור
#הצהרה מותנית בתוך הלולאה כדי להגדיר את הנתיב עבור כל מסד נתונים
doc_path = str ( נָתִיב ( *חלקים_רלוונטיים ) / 'state_of_the_union.txt' )
שלב 5: טעינה ופיצול הנתונים
כעת, פשוט טען את הנתונים ופצל אותם לנתחים קטנים יותר כדי לשפר את הקריאה וההבנה שלהם. צור הטמעות של הנתונים על ידי המרת הטקסט למספרים המייצרים את הרווחים הווקטוריים שלהם ושמירתם במסד הנתונים Chorma:
מ langchain. טוען_מסמכים יְבוּא TextLoader#טעינת מערך נתונים מהנתיב שלו ואחסן את הנתחים הקטנים שלו במסד הנתונים
מעמיס = TextLoader ( doc_path )
מסמכים = מעמיס. לִטעוֹן ( )
text_splitter = CharacterTextSplitter ( chunk_size = 2000 , chunk_overlap = 0 )
טקסטים = text_splitter. פיצול_מסמכים ( מסמכים )
#המר טקסט למספרים ואחסן את ההטמעות במסד הנתונים
הטבעות = OpenAIEbeddings ( )
docsearch = Chroma. from_documents ( טקסטים , הטבעות , collection_name = 'מדינת האיחוד' )
שלב 6: יצירת רטריבר
כדי לשלב מאגרי סוכן וקטור, נדרש ליצור רטריבר בשיטת RetrievalQA() מתוך המסגרת LangChain. שיטת אחזור זו מומלצת כדי לקבל נתונים ממאגרי וקטורים באמצעות הסוכנים ככלי לעבודה עם מסדי הנתונים:
מצב_האיחוד = שליפהQA. from_chain_type (llm = llm , סוג_שרשרת = 'דברים' , מחזיר = docsearch. as_retriever ( )
)
טען מערך נתונים נוסף כדי לשלב את הסוכן עם מערכי נתונים מרובים או מאגרי וקטור:
מעמיס = WebBaseLoader ( 'https://beta.ruff.rs/docs/faq/' )אחסן את מערך הנתונים של ruff ב- chromadb לאחר יצירת הנתחים הקטנים יותר של הנתונים גם עם וקטורי הטבעה:
מסמכים = מעמיס. לִטעוֹן ( )ruff_texts = text_splitter. פיצול_מסמכים ( מסמכים )
ruff_db = Chroma. from_documents ( ruff_texts , הטבעות , collection_name = 'רוצה' )
ruff = שליפהQA. from_chain_type (
llm = llm , סוג_שרשרת = 'דברים' , מחזיר = ruff_db. as_retriever ( )
)
שיטה 1: שילוב של סוכן עם חנויות וקטור
השיטה הראשונה לשילוב בין סוכנים ומאגרים וקטוריים כדי לחלץ מידע מוזכרת להלן:
שלב 1: הגדר כלים
כעת, כשמאגרי הווקטור מוגדרים, ממשיכים לכיוון בניית הרכיב השני בתהליך שלנו, כלומר סוכן. כדי ליצור את הסוכן עבור התהליך, ייבא את הספריות באמצעות התלות כמו סוכנים, כלים וכו'.
מ langchain. סוכנים יְבוּא initialize_agentמ langchain. סוכנים יְבוּא AgentType
#קבלת כלים מה-LangChain לבניית הסוכן
מ langchain. כלים יְבוּא BaseTool
מ langchain. llms יְבוּא OpenAI
#קבלת LLMMathChain מרשתות לבניית מודל השפה
מ langchain. שרשראות יְבוּא LLMMathChain
מ langchain. שירותים יְבוּא SerpAPIWrapper
מ langchain. סוכנים יְבוּא כְּלִי
הגדר את הכלים לשימוש עם הסוכנים באמצעות מערכת QA או אחזור שהוגדר קודם לכן עם השם והתיאור של הכלים:
כלים = [כְּלִי (
שֵׁם = 'מערכת QA של מצב האיגוד' ,
func = מצב_האיחוד. לָרוּץ ,
תיאור = 'מספק תשובות לשאלות הקשורות למערך הנתונים הטעון עם קלט כשאלה מעוצבת במלואה' ,
) ,
כְּלִי (
שֵׁם = 'מערכת Ruff QA' ,
func = ruff. לָרוּץ ,
תיאור = 'מספק תשובות לשאלות על ruff (לבנת פיתון) עם קלט כשאלה מעוצבת במלואה' ,
) ,
]
שלב 2: אתחול הסוכן
לאחר הגדרת הכלים, פשוט הגדר את הסוכן בארגומנט של שיטת initializa_agent() . הסוכן בו אנו משתמשים כאן הוא ZERO_SHOT_REACT_DESCRIPTION יחד עם הכלים, llm (מודל שפה), ומילולי:
סוֹכֵן = initialize_agent (כלים , llm , סוֹכֵן = AgentType. ZERO_SHOT_REACT_DESCRIPTION , מִלוּלִי = נָכוֹן
)
שלב 3: בדוק את הסוכן
פשוט הפעל את הסוכן באמצעות שיטת run() המכילה את השאלה בארגומנט שלה:
סוֹכֵן. לָרוּץ ('מה אמר הנשיא ג'ו ביידן על קאנג'י חום בכתובת'
)
צילום המסך הבא מציג את התשובה שחולצה משני מאגרי הנתונים באמצעות התצפית המאוחסנת בזיכרון של הסוכן:
שיטה 2: שימוש בסוכן כנתב
דרך נוספת לשלב את שני הרכיבים היא באמצעות הסוכן כנתב והדבר הבא מסביר את התהליך:
שלב 1: הגדר כלים
השימוש בסוכן בתור הנתב פירושו שמערכת RetrievalQA תחזיר את הפלט ישירות כאשר הכלים מוגדרים להחזיר את הפלט ישירות:
כלים = [#הגדרת הכלים הנדרשים לבניית הסוכן לקבלת נתונים מהנתונים
כְּלִי (
שֵׁם = 'מערכת QA של מצב האיגוד' ,
func = מצב_האיחוד. לָרוּץ ,
תיאור = 'מספק תשובות לשאלות הקשורות למערך הנתונים הטעון עם קלט כשאלה שלמה' ,
return_direct = נָכוֹן ,
) ,
כְּלִי (
שֵׁם = 'מערכת Ruff QA' ,
func = ruff. לָרוּץ ,
תיאור = 'מספק תשובות לשאלות על ruff (לינטר פיתון) עם קלט כשאלה שלמה' ,
return_direct = נָכוֹן ,
) ,
]
שלב 2: אתחול ובדוק את הסוכן
לאחר הגדרת הכלים פשוט הגדר את הסוכן שיכול לשמש אך ורק בתור הנתב באמצעות שיטת initialize_agent():
סוֹכֵן = initialize_agent (כלים , llm , סוֹכֵן = AgentType. ZERO_SHOT_REACT_DESCRIPTION , מִלוּלִי = נָכוֹן
)
בדוק את הסוכן על ידי מתן שאלת הקלט בשיטת agent.run() על ידי ביצוע הפקודה הבאה:
סוֹכֵן. לָרוּץ ('מה אמר הנשיא ג'ו ביידן על קאנג'י חום בכתובת'
)
תְפוּקָה
צילום המסך של הפלט מציג שהסוכן פשוט החזיר את התשובה לשאלה ממערך הנתונים שחולץ על ידי מערכת RetrievalQA:
שיטה 3: שימוש בסוכן עם Multi-Hop Vector Store
השיטה השלישית שבה המפתחים יכולים לשלב גם חנויות סוכנים וגם וקטורים היא עבור שאילתות חנות וקטור מרובה הופ. הסעיף הבא מסביר את התהליך המלא:
שלב 1: הגדר כלים
השלב הראשון הוא, כרגיל, הגדרת הכלים המשמשים לבניית הסוכנים לחילוץ נתונים ממאגרי הנתונים:
כלים = [כְּלִי (
שֵׁם = 'מערכת QA של מצב האיגוד' ,
func = מצב_האיחוד. לָרוּץ ,
תיאור = 'מספק תשובות לשאלות הקשורות למערך הנתונים הטעון עם קלט כשאלה מעוצבת במלואה, מבלי להפנות לשום כינוי מהשיחה הקודמת' ,
) ,
כְּלִי (
שֵׁם = 'מערכת Ruff QA' ,
func = ruff. לָרוּץ ,
תיאור = 'מספק תשובות לשאלות הקשורות למערך הנתונים הטעון עם קלט כשאלה מעוצבת במלואה, מבלי להפנות לשום כינוי מהשיחה הקודמת' ,
) ,
]
שלב 2: אתחול ובדוק את הסוכן
לאחר מכן, בנה את משתנה הסוכן באמצעות שיטת initialize_agent() עם שם הסוכן:
סוֹכֵן = initialize_agent (כלים , llm , סוֹכֵן = AgentType. ZERO_SHOT_REACT_DESCRIPTION , מִלוּלִי = נָכוֹן
)
הפעל את הסוכן באמצעות שאלת ריבוי הופ המכילה יותר מאספקט או תכונה אחת שכן בלוק הקוד הבא מכיל שאלה כזו:
סוֹכֵן. לָרוּץ ('באיזה כלי משתמש ruff כדי לדרוס מחברות פייתון והאם מישהו מהדוברים הזכיר את הכלי בכתובת שלו'
)
תְפוּקָה
צילום המסך הבא מצביע על כך שהסוכן צריך לעבור על השאלה כדי להבין את מורכבותה. הוא החזיר את התשובה שחולצה על ידי מערכת ה-QA ממאגרי הנתונים המרובים שהעלינו קודם לכן בתהליך:
זה הכל על איך לשלב סוכנים וחנויות וקטורים ב-LangChain.
סיכום
כדי לשלב סוכנים עם חנויות הווקטור ב-LangChain, התחל עם התקנת מודולים להגדרת הסביבה וטעינת מערכי נתונים. הגדר את מאגרי הווקטור לטעינת נתונים על ידי פיצולם לנתחים קטנים יותר תחילה ולאחר מכן בנה את מודל השפה באמצעות שיטת OpenAI(). הגדר את הסוכן כדי לשלב אותו עם מאגר הווקטור כדי לחלץ נתונים עבור סוגים שונים של שאילתות. מאמר זה הרחיב את תהליך השילוב של סוכנים וחנויות וקטורים ב-LangChain.