מתאר מהיר
פוסט זה ידגים את הדברים הבאים:
- כיצד להוסיף זיכרון גם לסוכן וגם לכלים שלו ב-LangChain
- שלב 1: התקנת מסגרות
- שלב 2: הגדרת סביבות
- שלב 3: ייבוא ספריות
- שלב 4: הוספת ReadOnlyMemory
- שלב 5: הגדרת כלים
- שלב 6: בניית הסוכן
- שיטה 1: שימוש ב-ReadOnlyMemory
- שיטה 2: שימוש באותו זיכרון הן עבור הסוכן והן עבור כלים
- סיכום
כיצד להוסיף זיכרון גם לסוכן וגם לכלים שלו ב-LangChain?
הוספת זיכרון לסוכנים ולכלים מאפשרת להם לעבוד טוב יותר עם היכולת להשתמש בהיסטוריית הצ'אט של המודל. עם זיכרון, הסוכן יכול להחליט ביעילות איזה כלי לפרוס ומתי. עדיף להשתמש ב' זיכרון לקריאה בלבד ' הן לסוכנים והן לכלים כך שהם לא יוכלו לשנות אותו. כדי ללמוד את התהליך של הוספת זיכרון הן לסוכנים והן לכלים ב-LangChain, עברו על השלבים המפורטים:
שלב 1: התקנת מסגרות
קודם כל, התקן את langchain-ניסיוני מודול כדי לקבל את התלות שלו לבניית מודלים וכלים של שפה עבור הסוכן. LangChain ניסיוני הוא המודול שמקבל את התלות לבניית מודלים המשמשים בעיקר לניסויים ובדיקות:
pip להתקין langchain - נִסיוֹנִי
להשיג את תוצאות חיפוש בגוגל מודולים עם התלות של OpenAI כדי לקבל את התשובות הרלוונטיות ביותר מהאינטרנט:
pip להתקין את Openai Google - לחפש - תוצאות
שלב 2: הגדרת סביבות
כדי לבנות את המודל שמקבל תשובות מהאינטרנט, נדרש להגדיר את הסביבות באמצעות OpenAI ו SerpAPi מפתחות:
יְבוּא אתה
יְבוּא getpass
אתה. בְּעֵרֶך [ 'OPENAI_API_KEY' ] = getpass. getpass ( 'מפתח API של OpenAI:' )
אתה. בְּעֵרֶך [ 'SERPAPI_API_KEY' ] = getpass. getpass ( 'מפתח API של Serpapi:' )
שלב 3: ייבוא ספריות
לאחר הגדרת הסביבות, ייבא את הספריות כדי לבנות את הכלים עבור הסוכן ואת הזיכרון הנוסף לשילוב איתם. הקוד הבא משתמש בסוכנים, בזיכרון, ב-llms, בשרשראות, בהנחיות ובכלי השירות כדי לקבל את הספריות הנדרשות:
מ-langchain. סוכנים יְבוּא ZeroShotAgent , כְּלִי , AgentExecutorמ-langchain. זיכרון יְבוּא ConversationBufferMemory , ReadOnlySharedMemory
מ-langchain. llms יְבוּא OpenAI
#קבל את הספרייה ל בניית השרשרת באמצעות LangChain
מ-langchain. שרשראות יְבוּא LLMChain
מ-langchain. הנחיות יְבוּא PromptTemplate
#קבל את הספרייה ל לקבל את המידע מהאינטרנט
מ-langchain. שירותים יְבוּא SerpAPIWrapper
שלב 4: הוספת ReadOnlyMemory
הגדר את התבנית עבור הסוכן כדי להתחיל בביצוע משימות ברגע שהמשתמש מספק את הקלט. לאחר מכן, הוסף את 'ConversationBufferMemory()' כדי לאחסן את היסטוריית הצ'אט של הדגם ולאתחל את 'זיכרון לקריאה בלבד' עבור הסוכנים והכלים שלו:
תבנית = '' 'זו שיחה בין אדם לבוט:{היסטורית שיחה}
#הגדר את המבנה לחילוץ הסיכום המדויק והקל
סכם את הצ'אט עבור {input}:
' ''
מיידי = PromptTemplate ( משתני_קלט = [ 'קֶלֶט' , 'היסטורית שיחה' ] , תבנית = תבנית )
זיכרון = ConversationBufferMemory ( זיכרון_מפתח = 'היסטורית שיחה' )
זיכרון לקריאה בלבד = ReadOnlySharedMemory ( זיכרון = זיכרון )
#שרשרת סיכום לשילוב כל הרכיבים ל לקבל את סיכום השיחה
שרשרת_סיכום = LLMChain (
llm = OpenAI ( ) ,
מיידי = מיידי ,
מִלוּלִי = נָכוֹן ,
זיכרון = זיכרון לקריאה בלבד ,
)
שלב 5: הגדרת כלים
כעת, הגדר כלים כמו חיפוש וסיכום כדי לקבל את התשובה מהאינטרנט יחד עם סיכום הצ'אט:
לחפש = SerpAPIWrapper ( )כלים = [
כְּלִי (
שֵׁם = 'לחפש' ,
func = לחפש. לָרוּץ ,
תיאור = 'תגובות נכונות לשאילתות הממוקדות לגבי האירועים האחרונים' ,
) ,
כְּלִי (
שֵׁם = 'סיכום' ,
func = שרשרת_סיכום. לָרוּץ ,
תיאור = 'מועיל לסכם את הצ'אט והקלט לכלי זה צריך להיות מחרוזת, המייצגת מי יקרא את הסיכום הזה' ,
) ,
]
שלב 6: בניית הסוכן
הגדר את הסוכן ברגע שהכלים מוכנים לבצע את המשימות הנדרשות ולחלץ את התשובות מהאינטרנט. ה ' קידומת המשתנה ' מבוצע לפני שהסוכנים מקצים משימה כלשהי לכלים וה' סִיוֹמֶת ' מבוצע לאחר שהכלים חילצו את התשובה:
קידומת = '' 'קח שיחה עם אדם, ענה על השאלות הבאות כמיטב יכולתך על ידי גישה לכלים הבאים:' ''סִיוֹמֶת = '' 'התחל!'
#מִבְנֶה ל הסוכן להתחיל להשתמש בכלים תוך כדי שימוש בזיכרון
{ היסטורית שיחה }
שְׁאֵלָה : { קֶלֶט }
{ agent_scratchpad } '' '
prompt = ZeroShotAgent.create_prompt(
#configure תבניות הנחיות כדי להבין את ההקשר של השאלה
כלים,
prefix=prefix,
סיומת=סיומת,
input_variables=[' קֶלֶט ',' היסטורית שיחה ',' agent_scratchpad '],
)
שיטה 1: שימוש בזיכרון ReadOnlyMemory
ברגע שהסוכן מוגדר להפעיל את הכלים, המודל עם ReadOnlyMemory הוא ה- מועדף דרך לבנות ולבצע את השרשראות כדי להביא תשובות והתהליך הוא כדלקמן:
שלב 1: בניית השרשרת
השלב הראשון בשיטה זו הוא לבנות את השרשרת ואת המבצע עבור 'ZeroShotAgent()' עם הטיעונים שלה. ה 'LLMCain()' משמש לבניית הקשר בין כל הצ'אטים במודל השפה באמצעות הארגומנטים llm ו-prompt. הסוכן משתמש ב-llm_chain, tools, and verbose כארגומנט שלו ובונה agent_chain כדי להפעיל את שני הסוכנים והכלים שלו עם הזיכרון:
llm_chain = LLMChain ( llm = OpenAI ( טֶמפֶּרָטוּרָה = 0 ) , מיידי = מיידי )סוֹכֵן = ZeroShotAgent ( llm_chain = llm_chain , כלים = כלים , מִלוּלִי = נָכוֹן )
שרשרת_סוכן = AgentExecutor. מ_סוכן_ו_כלים (
סוֹכֵן = סוֹכֵן , כלים = כלים , מִלוּלִי = נָכוֹן , זיכרון = זיכרון
)
שלב 2: בדיקת השרשרת
תתקשר ל שרשרת_סוכן באמצעות שיטת run() כדי לשאול את השאלה מהאינטרנט:
שרשרת_סוכן. לָרוּץ ( קֶלֶט = 'מה זה LangChain' )הסוכן שלף את התשובה מהאינטרנט באמצעות כלי החיפוש:
המשתמש יכול לשאול את שאלת ההמשך הלא ברורה כדי לבדוק את הזיכרון המחובר לסוכן:
שרשרת_סוכן. לָרוּץ ( קֶלֶט = 'מי פיתח את זה?' )הסוכן השתמש בצ'אט הקודם כדי להבין את ההקשר של השאלות והביא את התשובות כפי שמוצגות בצילום המסך הבא:
הסוכן משתמש בכלי (summary_chain) כדי לחלץ סיכום של כל התשובות שחולצו בעבר באמצעות זיכרון הסוכן:
שרשרת_סוכן. לָרוּץ (קֶלֶט = 'תודה! תסכם את השיחה, לבני ה-5'
)
תְפוּקָה
סיכום השאלות שנשאלו בעבר הוצג עבור ילד בן 5 בצילום המסך הבא:
שלב 3: בדיקת הזיכרון
הדפס את זיכרון המאגר כדי לחלץ את הצ'אטים המאוחסנים בו באמצעות הקוד הבא:
הדפס ( שרשרת_סוכן. זיכרון . בַּלָם )הצ'אטים בסדר הנכון ללא כל שינוי הוצגו בקטע הבא:
שיטה 2: שימוש באותו זיכרון הן עבור הסוכן והן עבור כלים
השיטה השנייה שאינה מומלצת על ידי הפלטפורמה היא שימוש בזיכרון המאגר הן עבור סוכנים והן עבור כלים. הכלים יכולים לשנות את הצ'אטים המאוחסנים בזיכרון שעלולים להחזיר פלטים שקריים בשיחות גדולות:
שלב 1: בניית השרשרת
שימוש בקוד המלא מהתבנית כדי לבנות את הכלים והשרשרות עבור הסוכנים בשינוי קטן מכיוון שה- ReadOnlyMemory לא נוסף הפעם:
תבנית = '' 'זו שיחה בין אדם לבוט:{היסטורית שיחה}
כתוב סיכום של השיחה עבור {input}:
' ''
#בנה את מבנה הצ'אט מִמְשָׁק שימוש בתבנית ההנחיה על ידי הוספת הזיכרון עם השרשרת
מיידי = PromptTemplate ( משתני_קלט = [ 'קֶלֶט' , 'היסטורית שיחה' ] , תבנית = תבנית )
זיכרון = ConversationBufferMemory ( זיכרון_מפתח = 'היסטורית שיחה' )
שרשרת_סיכום = LLMChain (
llm = OpenAI ( ) ,
מיידי = מיידי ,
מִלוּלִי = נָכוֹן ,
זיכרון = זיכרון ,
)
#בנה את הכלים ( חיפוש וסיכום ) ל הגדרת הסוכנים
לחפש = SerpAPIWrapper ( )
כלים = [
כְּלִי (
שֵׁם = 'לחפש' ,
func = לחפש. לָרוּץ ,
תיאור = 'תגובות נכונות לשאילתות הממוקדות לגבי האירועים האחרונים' ,
) ,
כְּלִי (
שֵׁם = 'סיכום' ,
func = שרשרת_סיכום. לָרוּץ ,
תיאור = 'מועיל לקבל את סיכום הצ'אט וצריך קלט מחרוזת לכלי זה המייצג מי יקרא את הסיכום הזה' ,
) ,
]
#הסבר את השלבים ל הסוכן להשתמש בכלים כדי לחלץ מידע ל השיחה
קידומת = '' 'לנהל שיחה עם אדם, לענות על השאילתות בצורה הטובה ביותר על ידי גישה לכלים הבאים:' ''
סִיוֹמֶת = '' 'התחל!'
#מִבְנֶה ל הסוכן להתחיל להשתמש בכלים תוך כדי שימוש בזיכרון
{ היסטורית שיחה }
שְׁאֵלָה : { קֶלֶט }
{ agent_scratchpad } '' '
prompt = ZeroShotAgent.create_prompt(
#configure תבניות הנחיות כדי להבין את ההקשר של השאלה
כלים,
prefix=prefix,
סיומת=סיומת,
input_variables=[' קֶלֶט ',' היסטורית שיחה ',' agent_scratchpad '],
)
#לשלב את כל הרכיבים תוך כדי בניית המוציא לפועל
llm_chain = LLMChain(llm=OpenAI(temperatur=0), prompt=prompt)
agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)
agent_chain = AgentExecutor.from_agent_and_tools(
סוכן=סוכן, כלים=כלים, מילולי=אמת, זיכרון=זיכרון
)
שלב 2: בדיקת השרשרת
הפעל את הקוד הבא:
שרשרת_סוכן. לָרוּץ ( קֶלֶט = 'מה זה LangChain' )התשובה מוצגת בהצלחה ומאוחסנת בזיכרון:
שאל את שאלת ההמשך מבלי לתת הרבה מההקשר:
שרשרת_סוכן. לָרוּץ ( קֶלֶט = 'מי פיתח את זה?' )הסוכן משתמש בזיכרון כדי להבין את השאלה על ידי הפיכתה ולאחר מכן מדפיס את התשובה:
קבלו את סיכום הצ'אט באמצעות הזיכרון המצורף לסוכן:
שרשרת_סוכן. לָרוּץ (קֶלֶט = 'תודה! תסכם את השיחה, לבני ה-5'
)
תְפוּקָה
הסיכום חולץ בהצלחה, ועד עכשיו הכל נראה אותו דבר אבל השינוי מגיע בשלב הבא:
שלב 3: בדיקת הזיכרון
חילוץ הודעות הצ'אט מהזיכרון באמצעות הקוד הבא:
הדפס ( שרשרת_סוכן. זיכרון . בַּלָם )הכלי שינה את ההיסטוריה על ידי הוספת שאלה נוספת שלא נשאלה במקור. זה קורה כשהמודל מבין את השאלה באמצעות a לשאול עצמי שְׁאֵלָה. הכלי חושב בטעות שהוא נשאל על ידי המשתמש ומתייחס אליו כאל שאילתה נפרדת. אז הוא מוסיף את השאלה הנוספת הזו גם לזיכרון, אשר תשמש לאחר מכן כדי לקבל את ההקשר של השיחה:
זה הכל לעת עתה.
סיכום
כדי להוסיף זיכרון גם לסוכן וגם לכלים שלו ב-LangChain, התקן את המודולים כדי לקבל את התלות שלהם ולייבא מהם ספריות. לאחר מכן, בנה את זיכרון השיחה, מודל השפה, הכלים והסוכן כדי להוסיף את הזיכרון. ה שיטה מומלצת כדי להוסיף את הזיכרון הוא משתמש ב- ReadOnlyMemory לסוכן ובכלים שלו לאחסון היסטוריית הצ'אט. המשתמש יכול גם להשתמש ב- זיכרון שיחה הן לסוכנים והן לכלים. אבל, הם מקבלים מְבוּלבָּל לפעמים ולשנות את הצ'אטים בזיכרון.