اس کے بنیادی طور پر، لینگ چین ایپلی کیشنز کو تیار کرنے کے لیے تیار کردہ ایک جدید فریم ورک ہے جو زبان کے ماڈلز کی صلاحیتوں سے فائدہ اٹھاتا ہے۔ یہ ایک ٹول کٹ ہے جسے ڈویلپرز کے لیے ایسی ایپلی کیشنز بنانے کے لیے ڈیزائن کیا گیا ہے جو سیاق و سباق سے آگاہ اور نفیس استدلال کے قابل ہوں۔
اس کا مطلب ہے کہ LangChain ایپلی کیشنز سیاق و سباق کو سمجھ سکتی ہیں، جیسے کہ فوری ہدایات یا مواد کو گراؤنڈ کرنے والے جوابات اور پیچیدہ استدلال کے کاموں کے لیے زبان کے ماڈلز کا استعمال کرتے ہیں، جیسے یہ فیصلہ کرنا کہ جواب کیسے دیا جائے یا کیا اقدامات کیے جائیں۔ LangChain ذہین ایپلی کیشنز کو تیار کرنے کے لیے ایک متفقہ نقطہ نظر کی نمائندگی کرتا ہے، اپنے متنوع اجزاء کے ساتھ تصور سے عمل درآمد تک کے سفر کو آسان بناتا ہے۔
لینگ چین کو سمجھنا
LangChain صرف ایک فریم ورک سے کہیں زیادہ ہے۔ یہ ایک مکمل ماحولیاتی نظام ہے جس میں کئی لازمی حصوں پر مشتمل ہے۔
- سب سے پہلے، LangChain لائبریریاں ہیں، جو Python اور JavaScript دونوں میں دستیاب ہیں۔ یہ لائبریریاں LangChain کی ریڑھ کی ہڈی ہیں، جو مختلف اجزاء کے لیے انٹرفیس اور انضمام پیش کرتی ہیں۔ وہ ان اجزاء کو مربوط زنجیروں اور ایجنٹوں میں یکجا کرنے کے لیے ایک بنیادی رن ٹائم فراہم کرتے ہیں، ساتھ ہی فوری استعمال کے لیے تیار کردہ نفاذات بھی۔
- اگلا، ہمارے پاس LangChain ٹیمپلیٹس ہیں۔ یہ وسیع پیمانے پر کاموں کے لیے تیار کردہ قابل تعنیات ریفرنس آرکیٹیکچرز کا مجموعہ ہیں۔ چاہے آپ چیٹ بوٹ یا پیچیدہ تجزیاتی ٹول بنا رہے ہوں، یہ ٹیمپلیٹس ایک ٹھوس نقطہ آغاز پیش کرتے ہیں۔
- LangServe ایک ورسٹائل لائبریری کے طور پر لینگ چین چینز کو REST APIs کے طور پر تعینات کرنے کے لیے قدم بڑھاتا ہے۔ یہ ٹول آپ کے LangChain پروجیکٹس کو قابل رسائی اور قابل توسیع ویب سروسز میں تبدیل کرنے کے لیے ضروری ہے۔
- آخر میں، لینگ اسمتھ ایک ڈویلپر پلیٹ فارم کے طور پر کام کرتا ہے۔ اسے کسی بھی LLM فریم ورک پر بنی ہوئی زنجیروں کو ڈیبگ کرنے، جانچنے، جانچنے اور مانیٹر کرنے کے لیے ڈیزائن کیا گیا ہے۔ LangChain کے ساتھ ہموار انضمام اسے ڈویلپرز کے لیے ایک ناگزیر ٹول بناتا ہے جس کا مقصد اپنی ایپلی کیشنز کو بہتر اور مکمل کرنا ہے۔
ایک ساتھ مل کر، یہ اجزاء آپ کو آسانی کے ساتھ ایپلیکیشنز کو تیار، پروڈکشن، اور تعینات کرنے کا اختیار دیتے ہیں۔ LangChain کے ساتھ، آپ لائبریریوں کا استعمال کرتے ہوئے، رہنمائی کے لیے ٹیمپلیٹس کا حوالہ دے کر اپنی درخواستیں لکھ کر شروع کرتے ہیں۔ LangSmith پھر آپ کی زنجیروں کا معائنہ، جانچ اور نگرانی میں آپ کی مدد کرتا ہے، اس بات کو یقینی بناتا ہے کہ آپ کی درخواستیں مسلسل بہتر ہو رہی ہیں اور تعیناتی کے لیے تیار ہیں۔ آخر میں، LangServe کے ساتھ، آپ آسانی سے کسی بھی چین کو API میں تبدیل کر سکتے ہیں، تعیناتی کو ہوا کا جھونکا بنا کر۔
اگلے حصوں میں، ہم مزید گہرائی میں جائیں گے کہ LangChain کو کیسے ترتیب دیا جائے اور ذہین، زبان کے ماڈل سے چلنے والی ایپلی کیشنز بنانے میں اپنا سفر شروع کیا جائے۔
ہمارے AI سے چلنے والے ورک فلو بلڈر کے ساتھ دستی کاموں اور ورک فلو کو خودکار بنائیں، جسے Nanonets نے آپ اور آپ کی ٹیموں کے لیے ڈیزائن کیا ہے۔
انسٹالیشن اور سیٹ اپ
کیا آپ LangChain کی دنیا میں غوطہ لگانے کے لیے تیار ہیں؟ اسے ترتیب دینا سیدھا ہے، اور یہ گائیڈ آپ کو مرحلہ وار عمل میں لے جائے گا۔
آپ کے LangChain سفر کا پہلا قدم اسے انسٹال کرنا ہے۔ آپ یہ آسانی سے پائپ یا کونڈا کا استعمال کر سکتے ہیں۔ اپنے ٹرمینل میں درج ذیل کمانڈ کو چلائیں:
pip install langchain
ان لوگوں کے لیے جو تازہ ترین خصوصیات کو ترجیح دیتے ہیں اور کچھ زیادہ ایڈونچر کے ساتھ آرام دہ ہیں، آپ براہ راست ذریعہ سے LangChain انسٹال کر سکتے ہیں۔ ریپوزٹری کو کلون کریں اور نیویگیٹ کریں۔ langchain/libs/langchain
ڈائریکٹری پھر، چلائیں:
pip install -e .
تجرباتی خصوصیات کے لیے، انسٹال کرنے پر غور کریں۔ langchain-experimental
. یہ ایک ایسا پیکیج ہے جس میں جدید کوڈ ہوتا ہے اور یہ تحقیق اور تجرباتی مقاصد کے لیے ہے۔ اسے استعمال کرتے ہوئے انسٹال کریں:
pip install langchain-experimental
LangChain CLI LangChain ٹیمپلیٹس اور LangServe پروجیکٹس کے ساتھ کام کرنے کے لیے ایک آسان ٹول ہے۔ LangChain CLI انسٹال کرنے کے لیے، استعمال کریں:
pip install langchain-cli
آپ کی LangChain زنجیروں کو REST API کے طور پر تعینات کرنے کے لیے LangServe ضروری ہے۔ یہ LangChain CLI کے ساتھ انسٹال ہو جاتا ہے۔
LangChain کو اکثر ماڈل فراہم کنندگان، ڈیٹا اسٹورز، APIs وغیرہ کے ساتھ انضمام کی ضرورت ہوتی ہے۔ اس مثال کے لیے، ہم OpenAI کے ماڈل APIs کا استعمال کریں گے۔ OpenAI Python پیکیج کو استعمال کرتے ہوئے انسٹال کریں:
pip install openai
API تک رسائی کے لیے، اپنی OpenAI API کلید کو ماحولیاتی متغیر کے طور پر سیٹ کریں:
export OPENAI_API_KEY="your_api_key"
متبادل طور پر، کلید کو براہ راست اپنے ازگر کے ماحول میں منتقل کریں:
import os
os.environ['OPENAI_API_KEY'] = 'your_api_key'
LangChain ماڈیولز کے ذریعے لینگویج ماڈل ایپلی کیشنز کی تخلیق کی اجازت دیتا ہے۔ یہ ماڈیول یا تو اکیلے کھڑے ہو سکتے ہیں یا پیچیدہ استعمال کے معاملات کے لیے بنائے جا سکتے ہیں۔ یہ ماڈیولز ہیں -
- ماڈل I/O: مختلف زبان کے ماڈلز کے ساتھ تعامل کی سہولت فراہم کرتا ہے، ان کے ان پٹ اور آؤٹ پٹس کو مؤثر طریقے سے ہینڈل کرتا ہے۔
- بازیافت: ایپلیکیشن کے مخصوص ڈیٹا تک رسائی اور اس کے ساتھ تعامل کو قابل بناتا ہے، متحرک ڈیٹا کے استعمال کے لیے اہم ہے۔
- ایجنٹس: ایپلی کیشنز کو اعلیٰ سطحی ہدایات پر مبنی مناسب ٹولز منتخب کرنے کے لیے بااختیار بنائیں، فیصلہ سازی کی صلاحیتوں میں اضافہ کریں۔
- زنجیروں: پہلے سے طے شدہ، دوبارہ قابل استعمال کمپوزیشن پیش کرتا ہے جو ایپلیکیشن کی ترقی کے لیے تعمیراتی بلاکس کا کام کرتی ہے۔
- یاد داشت: سیاق و سباق سے آگاہ تعاملات کے لیے ضروری، متعدد سلسلہ عمل میں اطلاق کی حالت کو برقرار رکھتا ہے۔
ہر ماڈیول مخصوص ترقیاتی ضروریات کو نشانہ بناتا ہے، جس سے LangChain کو جدید لینگویج ماڈل ایپلی کیشنز بنانے کے لیے ایک جامع ٹول کٹ بناتی ہے۔
مندرجہ بالا اجزاء کے ساتھ، ہمارے پاس بھی ہے LangChain اظہار کی زبان (LCEL)، جو آسانی سے ماڈیولز کو ایک ساتھ ترتیب دینے کا ایک اعلانیہ طریقہ ہے، اور یہ یونیورسل رن ایبل انٹرفیس کا استعمال کرتے ہوئے اجزاء کی زنجیر کو قابل بناتا ہے۔
LCEL کچھ اس طرح لگتا ہے -
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import BaseOutputParser # Example chain
chain = ChatPromptTemplate() | ChatOpenAI() | CustomOutputParser()
اب جب کہ ہم نے بنیادی باتوں کا احاطہ کر لیا ہے، ہم جاری رکھیں گے:
- ہر Langchain ماڈیول کو تفصیل کے ساتھ گہرائی میں کھودیں۔
- LangChain اظہار کی زبان استعمال کرنے کا طریقہ سیکھیں۔
- عام استعمال کے معاملات کو دریافت کریں اور ان پر عمل کریں۔
- LangServe کے ساتھ اینڈ ٹو اینڈ ایپلیکیشن تعینات کریں۔
- ڈیبگنگ، ٹیسٹنگ اور مانیٹرنگ کے لیے لینگ سمتھ کو چیک کریں۔
آو شروع کریں!
ماڈیول I : ماڈل I/O
LangChain میں، کسی بھی ایپلیکیشن کا بنیادی عنصر زبان کے ماڈل کے گرد گھومتا ہے۔ یہ ماڈیول کسی بھی زبان کے ماڈل کے ساتھ مؤثر طریقے سے انٹرفیس کرنے کے لیے ضروری بلڈنگ بلاکس فراہم کرتا ہے، بغیر کسی رکاوٹ کے انضمام اور مواصلات کو یقینی بناتا ہے۔
ماڈل I/O کے کلیدی اجزاء
- LLMs اور چیٹ ماڈلز (ایک دوسرے کے ساتھ استعمال کیا جاتا ہے):
- ایل ایل ایمز:
- ڈیفینیشن: خالص متن کی تکمیل کے ماڈل۔
- ان پٹ / آؤٹ پٹ: ان پٹ کے طور پر ٹیکسٹ سٹرنگ لیں اور آؤٹ پٹ کے طور پر ٹیکسٹ سٹرنگ واپس کریں۔
- چیٹ ماڈلز
- ایل ایل ایمز:
- ڈیفینیشن: وہ ماڈل جو زبان کے ماڈل کو بنیاد کے طور پر استعمال کرتے ہیں لیکن ان پٹ اور آؤٹ پٹ فارمیٹس میں مختلف ہوتے ہیں۔
- ان پٹ / آؤٹ پٹ: چیٹ پیغامات کی فہرست بطور ان پٹ قبول کریں اور چیٹ پیغام واپس کریں۔
- پرامپٹس: نمونہ بنائیں، متحرک طور پر منتخب کریں، اور ماڈل ان پٹس کا نظم کریں۔ لچکدار اور سیاق و سباق سے متعلق مخصوص اشارے بنانے کی اجازت دیتا ہے جو زبان کے ماڈل کے جوابات کی رہنمائی کرتے ہیں۔
- آؤٹ پٹ پارسر: ماڈل آؤٹ پٹس سے معلومات نکالیں اور فارمیٹ کریں۔ زبان کے ماڈلز کے خام آؤٹ پٹ کو سٹرکچرڈ ڈیٹا یا ایپلیکیشن کے لیے درکار مخصوص فارمیٹس میں تبدیل کرنے کے لیے مفید ہے۔
ایل ایل ایمز
LangChain کا OpenAI، Cohere، اور Hugging Face جیسے Large Language Models (LLMs) کے ساتھ انضمام اس کی فعالیت کا ایک بنیادی پہلو ہے۔ LangChain خود LLMs کی میزبانی نہیں کرتا ہے لیکن مختلف LLMs کے ساتھ بات چیت کرنے کے لیے یکساں انٹرفیس پیش کرتا ہے۔
یہ سیکشن LangChain میں OpenAI LLM ریپر کے استعمال کا ایک جائزہ فراہم کرتا ہے، جو کہ دیگر LLM اقسام پر بھی لاگو ہوتا ہے۔ ہم اسے پہلے ہی "شروع کرنا" سیکشن میں انسٹال کر چکے ہیں۔ آئیے ایل ایل ایم کو شروع کریں۔
from langchain.llms import OpenAI
llm = OpenAI()
- ایل ایل ایم لاگو کرتے ہیں۔ چلانے کے قابل انٹرفیسکی بنیادی عمارت بلاک LangChain اظہار کی زبان (LCEL). اس کا مطلب ہے کہ وہ حمایت کرتے ہیں۔
invoke
,ainvoke
,stream
,astream
,batch
,abatch
,astream_log
کالز - ایل ایل ایم قبول کرتے ہیں۔ ڈور بطور ان پٹ، یا ایسی اشیاء جن کو سٹرنگ پرامپٹس پر مجبور کیا جا سکتا ہے، بشمول
List[BaseMessage]
اورPromptValue
. (ان کے بارے میں مزید بعد میں)
آئیے کچھ مثالیں دیکھتے ہیں۔
response = llm.invoke("List the seven wonders of the world.")
print(response)
متن کے جواب کو اسٹریم کرنے کے لیے آپ متبادل طور پر اسٹریم طریقہ کو کال کرسکتے ہیں۔
for chunk in llm.stream("Where were the 2012 Olympics held?"): print(chunk, end="", flush=True)
چیٹ ماڈلز
چیٹ ماڈلز کے ساتھ LangChain کا انضمام، زبان کے ماڈلز کا ایک خصوصی تغیر، انٹرایکٹو چیٹ ایپلی کیشنز بنانے کے لیے ضروری ہے۔ جب کہ وہ زبان کے ماڈلز کو اندرونی طور پر استعمال کرتے ہیں، چیٹ کے ماڈلز ایک الگ انٹرفیس پیش کرتے ہیں جو چیٹ پیغامات کے ارد گرد مرکوز ہوتا ہے بطور ان پٹ اور آؤٹ پٹ۔ یہ سیکشن LangChain میں OpenAI کے چیٹ ماڈل کے استعمال کا تفصیلی جائزہ فراہم کرتا ہے۔
from langchain.chat_models import ChatOpenAI
chat = ChatOpenAI()
LangChain میں چیٹ ماڈل مختلف پیغام کی اقسام کے ساتھ کام کرتے ہیں جیسے AIMessage
, HumanMessage
, SystemMessage
, FunctionMessage
، اور ChatMessage
(ایک صوابدیدی کردار پیرامیٹر کے ساتھ)۔ عام طور پر، HumanMessage
, AIMessage
، اور SystemMessage
سب سے زیادہ کثرت سے استعمال کیا جاتا ہے.
چیٹ ماڈل بنیادی طور پر قبول کرتے ہیں۔ List[BaseMessage]
ان پٹ کے طور پر. سٹرنگز کو تبدیل کیا جا سکتا ہے۔ HumanMessage
، اور PromptValue
بھی حمایت کی ہے.
from langchain.schema.messages import HumanMessage, SystemMessage
messages = [ SystemMessage(content="You are Micheal Jordan."), HumanMessage(content="Which shoe manufacturer are you associated with?"),
]
response = chat.invoke(messages)
print(response.content)
پرامپٹس
متعلقہ اور مربوط نتائج پیدا کرنے کے لیے زبان کے ماڈلز کی رہنمائی کے لیے اشارے ضروری ہیں۔ وہ سادہ ہدایات سے لے کر پیچیدہ چند شاٹ مثالوں تک ہو سکتے ہیں۔ LangChain میں، پرامپٹس کو ہینڈل کرنا ایک بہت ہی منظم عمل ہو سکتا ہے، کئی مخصوص کلاسز اور فنکشنز کی بدولت۔
لینگ چین کا PromptTemplate
کلاس سٹرنگ پرامپٹس بنانے کا ایک ورسٹائل ٹول ہے۔ یہ Python کا استعمال کرتا ہے۔ str.format
نحو، متحرک پرامپٹ جنریشن کی اجازت دیتا ہے۔ آپ پلیس ہولڈرز کے ساتھ ایک ٹیمپلیٹ کی وضاحت کر سکتے ہیں اور ضرورت کے مطابق انہیں مخصوص اقدار سے بھر سکتے ہیں۔
from langchain.prompts import PromptTemplate # Simple prompt with placeholders
prompt_template = PromptTemplate.from_template( "Tell me a {adjective} joke about {content}."
) # Filling placeholders to create a prompt
filled_prompt = prompt_template.format(adjective="funny", content="robots")
print(filled_prompt)
چیٹ ماڈلز کے لیے، اشارے زیادہ منظم ہوتے ہیں، جن میں مخصوص کرداروں کے ساتھ پیغامات شامل ہوتے ہیں۔ LangChain پیشکش کرتا ہے۔ ChatPromptTemplate
اس مقصد کے لیے.
from langchain.prompts import ChatPromptTemplate # Defining a chat prompt with various roles
chat_template = ChatPromptTemplate.from_messages( [ ("system", "You are a helpful AI bot. Your name is {name}."), ("human", "Hello, how are you doing?"), ("ai", "I'm doing well, thanks!"), ("human", "{user_input}"), ]
) # Formatting the chat prompt
formatted_messages = chat_template.format_messages(name="Bob", user_input="What is your name?")
for message in formatted_messages: print(message)
یہ نقطہ نظر متحرک ردعمل کے ساتھ انٹرایکٹو، مشغول چیٹ بوٹس کی تخلیق کی اجازت دیتا ہے۔
دونوں PromptTemplate
اور ChatPromptTemplate
LangChain Expression Language (LCEL) کے ساتھ بغیر کسی رکاوٹ کے انضمام کریں، انہیں بڑے، پیچیدہ ورک فلو کا حصہ بننے کے قابل بناتے ہوئے۔ اس پر ہم بعد میں مزید بات کریں گے۔
حسب ضرورت پرامپٹ ٹیمپلیٹس بعض اوقات ان کاموں کے لیے ضروری ہوتے ہیں جن میں منفرد فارمیٹنگ یا مخصوص ہدایات کی ضرورت ہوتی ہے۔ ایک حسب ضرورت پرامپٹ ٹیمپلیٹ بنانے میں ان پٹ متغیرات کی وضاحت اور اپنی مرضی کے مطابق فارمیٹنگ کا طریقہ شامل ہوتا ہے۔ یہ لچک LangChain کو درخواست کی مخصوص ضروریات کی ایک وسیع صف کو پورا کرنے کی اجازت دیتی ہے۔ مزید یہاں پڑھیں.
LangChain چند شاٹ پرامپٹنگ کو بھی سپورٹ کرتا ہے، جو ماڈل کو مثالوں سے سیکھنے کے قابل بناتا ہے۔ یہ خصوصیت ان کاموں کے لیے ضروری ہے جن کے لیے سیاق و سباق کی تفہیم یا مخصوص نمونوں کی ضرورت ہوتی ہے۔ چند شاٹ پرامپٹ ٹیمپلیٹس مثالوں کے سیٹ سے یا مثال سلیکٹر آبجیکٹ کو استعمال کر کے بنائے جا سکتے ہیں۔ مزید یہاں پڑھیں.
آؤٹ پٹ پارسر
آؤٹ پٹ پارسرز لینگچین میں ایک اہم کردار ادا کرتے ہیں، جو صارفین کو زبان کے ماڈلز کے ذریعے پیدا ہونے والے ردعمل کو تشکیل دینے کے قابل بناتے ہیں۔ اس سیکشن میں، ہم آؤٹ پٹ پارسر کے تصور کو دریافت کریں گے اور Langchain کے PydanticOutputParser، SimpleJsonOutputParser، CommaSeparatedListOutputParser، DatetimeOutputParser، اور XMLOoutputParser کا استعمال کرتے ہوئے کوڈ کی مثالیں فراہم کریں گے۔
پیڈینٹک آؤٹ پٹ پارسر
Langchain جوابات کو Pydantic ڈیٹا ڈھانچے میں پارس کرنے کے لیے PydanticOutputParser فراہم کرتا ہے۔ ذیل میں اسے استعمال کرنے کے طریقہ کار کی ایک مرحلہ وار مثال ہے:
from typing import List
from langchain.llms import OpenAI
from langchain.output_parsers import PydanticOutputParser
from langchain.prompts import PromptTemplate
from langchain.pydantic_v1 import BaseModel, Field, validator # Initialize the language model
model = OpenAI(model_name="text-davinci-003", temperature=0.0) # Define your desired data structure using Pydantic
class Joke(BaseModel): setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") @validator("setup") def question_ends_with_question_mark(cls, field): if field[-1] != "?": raise ValueError("Badly formed question!") return field # Set up a PydanticOutputParser
parser = PydanticOutputParser(pydantic_object=Joke) # Create a prompt with format instructions
prompt = PromptTemplate( template="Answer the user query.n{format_instructions}n{query}n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},
) # Define a query to prompt the language model
query = "Tell me a joke." # Combine prompt, model, and parser to get structured output
prompt_and_model = prompt | model
output = prompt_and_model.invoke({"query": query}) # Parse the output using the parser
parsed_result = parser.invoke(output) # The result is a structured object
print(parsed_result)
پیداوار ہو جائے گا:
SimpleJsonOutputParser
Langchain کا SimpleJsonOutputParser استعمال کیا جاتا ہے جب آپ JSON جیسے آؤٹ پٹ کو پارس کرنا چاہتے ہیں۔ یہاں ایک مثال ہے:
from langchain.output_parsers.json import SimpleJsonOutputParser # Create a JSON prompt
json_prompt = PromptTemplate.from_template( "Return a JSON object with `birthdate` and `birthplace` key that answers the following question: {question}"
) # Initialize the JSON parser
json_parser = SimpleJsonOutputParser() # Create a chain with the prompt, model, and parser
json_chain = json_prompt | model | json_parser # Stream through the results
result_list = list(json_chain.stream({"question": "When and where was Elon Musk born?"})) # The result is a list of JSON-like dictionaries
print(result_list)
CommaSeparatedListOutputParser
CommaSeparatedListOutputParser اس وقت کارآمد ہوتا ہے جب آپ ماڈل کے جوابات سے کوما سے الگ کردہ فہرستیں نکالنا چاہتے ہیں۔ یہاں ایک مثال ہے:
from langchain.output_parsers import CommaSeparatedListOutputParser
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI # Initialize the parser
output_parser = CommaSeparatedListOutputParser() # Create format instructions
format_instructions = output_parser.get_format_instructions() # Create a prompt to request a list
prompt = PromptTemplate( template="List five {subject}.n{format_instructions}", input_variables=["subject"], partial_variables={"format_instructions": format_instructions}
) # Define a query to prompt the model
query = "English Premier League Teams" # Generate the output
output = model(prompt.format(subject=query)) # Parse the output using the parser
parsed_result = output_parser.parse(output) # The result is a list of items
print(parsed_result)
ڈیٹ ٹائم آؤٹ پٹ پارسر
لینگچین کا ڈیٹ ٹائم آؤٹ پٹ پارسر ڈیٹ ٹائم کی معلومات کو پارس کرنے کے لیے ڈیزائن کیا گیا ہے۔ اسے استعمال کرنے کا طریقہ یہاں ہے:
from langchain.prompts import PromptTemplate
from langchain.output_parsers import DatetimeOutputParser
from langchain.chains import LLMChain
from langchain.llms import OpenAI # Initialize the DatetimeOutputParser
output_parser = DatetimeOutputParser() # Create a prompt with format instructions
template = """
Answer the user's question:
{question}
{format_instructions} """ prompt = PromptTemplate.from_template( template, partial_variables={"format_instructions": output_parser.get_format_instructions()},
) # Create a chain with the prompt and language model
chain = LLMChain(prompt=prompt, llm=OpenAI()) # Define a query to prompt the model
query = "when did Neil Armstrong land on the moon in terms of GMT?" # Run the chain
output = chain.run(query) # Parse the output using the datetime parser
parsed_result = output_parser.parse(output) # The result is a datetime object
print(parsed_result)
یہ مثالیں یہ ظاہر کرتی ہیں کہ کس طرح Langchain کے آؤٹ پٹ پارسرز کو مختلف قسم کے ماڈل ردعمل کی تشکیل کے لیے استعمال کیا جا سکتا ہے، جس سے وہ مختلف ایپلی کیشنز اور فارمیٹس کے لیے موزوں ہیں۔ آؤٹ پٹ پارسر Langchain میں لینگویج ماڈل آؤٹ پٹ کے استعمال اور تشریح کو بڑھانے کے لیے ایک قابل قدر ٹول ہیں۔
ہمارے AI سے چلنے والے ورک فلو بلڈر کے ساتھ دستی کاموں اور ورک فلو کو خودکار بنائیں، جسے Nanonets نے آپ اور آپ کی ٹیموں کے لیے ڈیزائن کیا ہے۔
ماڈیول II: بازیافت
LangChain میں بازیافت ان ایپلی کیشنز میں ایک اہم کردار ادا کرتی ہے جن کے لیے صارف کے مخصوص ڈیٹا کی ضرورت ہوتی ہے، جو کہ ماڈل کے تربیتی سیٹ میں شامل نہیں ہے۔ یہ عمل، جسے Retrieval Augmented Generation (RAG) کے نام سے جانا جاتا ہے، اس میں بیرونی ڈیٹا حاصل کرنا اور اسے زبان کے ماڈل کی نسل کے عمل میں ضم کرنا شامل ہے۔ LangChain اس عمل کو آسان بنانے کے لیے ٹولز اور فنکشنلٹیز کا ایک جامع مجموعہ فراہم کرتا ہے، سادہ اور پیچیدہ ایپلی کیشنز دونوں کو پورا کرتا ہے۔
LangChain اجزاء کی ایک سیریز کے ذریعے بازیافت حاصل کرتا ہے جس پر ہم ایک ایک کرکے بحث کریں گے۔
دستاویز لوڈرز
LangChain میں دستاویز لوڈرز مختلف ذرائع سے ڈیٹا نکالنے کے قابل بناتے ہیں۔ 100 سے زیادہ لوڈرز دستیاب ہونے کے ساتھ، وہ دستاویز کی اقسام، ایپس اور ذرائع (نجی s3 بالٹیاں، عوامی ویب سائٹس، ڈیٹا بیس) کی حمایت کرتے ہیں۔
آپ اپنی ضروریات کی بنیاد پر دستاویز لوڈر کا انتخاب کر سکتے ہیں۔ یہاں.
یہ تمام لوڈرز ڈیٹا کو داخل کرتے ہیں۔ دستاویز کلاسز ہم بعد میں سیکھیں گے کہ دستاویز کی کلاسوں میں داخل کردہ ڈیٹا کو کیسے استعمال کیا جائے۔
ٹیکسٹ فائل لوڈر: ایک سادہ لوڈ کریں۔ .txt
ایک دستاویز میں فائل کریں.
from langchain.document_loaders import TextLoader loader = TextLoader("./sample.txt")
document = loader.load()
CSV لوڈر: ایک دستاویز میں CSV فائل لوڈ کریں۔
from langchain.document_loaders.csv_loader import CSVLoader loader = CSVLoader(file_path='./example_data/sample.csv')
documents = loader.load()
ہم فیلڈ کے نام بتا کر تجزیہ کو اپنی مرضی کے مطابق کرنے کا انتخاب کر سکتے ہیں۔
loader = CSVLoader(file_path='./example_data/mlb_teams_2012.csv', csv_args={ 'delimiter': ',', 'quotechar': '"', 'fieldnames': ['MLB Team', 'Payroll in millions', 'Wins']
})
documents = loader.load()
پی ڈی ایف لوڈرز: LangChain میں PDF لوڈرز پی ڈی ایف فائلوں سے مواد کو پارس کرنے اور نکالنے کے مختلف طریقے پیش کرتے ہیں۔ ہر لوڈر مختلف ضروریات کو پورا کرتا ہے اور مختلف بنیادی لائبریریوں کا استعمال کرتا ہے۔ ذیل میں ہر لوڈر کے لیے تفصیلی مثالیں ہیں۔
پی پی ڈی ایف لوڈر بنیادی پی ڈی ایف پارسنگ کے لیے استعمال ہوتا ہے۔
from langchain.document_loaders import PyPDFLoader loader = PyPDFLoader("example_data/layout-parser-paper.pdf")
pages = loader.load_and_split()
MathPixLoader ریاضی کے مواد اور خاکوں کو نکالنے کے لیے مثالی ہے۔
from langchain.document_loaders import MathpixPDFLoader loader = MathpixPDFLoader("example_data/math-content.pdf")
data = loader.load()
PyMuPDFLloader تیز ہے اور اس میں تفصیلی میٹا ڈیٹا نکالنا شامل ہے۔
from langchain.document_loaders import PyMuPDFLoader loader = PyMuPDFLoader("example_data/layout-parser-paper.pdf")
data = loader.load() # Optionally pass additional arguments for PyMuPDF's get_text() call
data = loader.load(option="text")
PDFMiner لوڈر ٹیکسٹ نکالنے پر زیادہ دانے دار کنٹرول کے لیے استعمال کیا جاتا ہے۔
from langchain.document_loaders import PDFMinerLoader loader = PDFMinerLoader("example_data/layout-parser-paper.pdf")
data = loader.load()
AmazonTextractPDFParser OCR اور دیگر جدید پی ڈی ایف پارسنگ خصوصیات کے لیے AWS Textract کا استعمال کرتا ہے۔
from langchain.document_loaders import AmazonTextractPDFLoader # Requires AWS account and configuration
loader = AmazonTextractPDFLoader("example_data/complex-layout.pdf")
documents = loader.load()
PDFMinerPDFasHTMLLoader سیمنٹک پارسنگ کے لیے PDF سے HTML تیار کرتا ہے۔
from langchain.document_loaders import PDFMinerPDFasHTMLLoader loader = PDFMinerPDFasHTMLLoader("example_data/layout-parser-paper.pdf")
data = loader.load()
PDFPlumberLoader تفصیلی میٹا ڈیٹا فراہم کرتا ہے اور فی صفحہ ایک دستاویز کی حمایت کرتا ہے۔
from langchain.document_loaders import PDFPlumberLoader loader = PDFPlumberLoader("example_data/layout-parser-paper.pdf")
data = loader.load()
مربوط لوڈرز: LangChain آپ کی ایپس (جیسے Slack، Sigma، Notion، Confluence، Google Drive اور بہت کچھ) اور ڈیٹا بیس سے براہ راست ڈیٹا لوڈ کرنے اور LLM ایپلی کیشنز میں استعمال کرنے کے لیے مختلف قسم کے کسٹم لوڈرز پیش کرتا ہے۔
مکمل فہرست ہے۔ یہاں.
اس کو واضح کرنے کے لیے ذیل میں چند مثالیں دی جارہی ہیں-
مثال I – سلیک
سلیک، ایک وسیع پیمانے پر استعمال ہونے والا فوری پیغام رسانی کا پلیٹ فارم، LLM ورک فلوز اور ایپلیکیشنز میں ضم کیا جا سکتا ہے۔
- اپنے سلیک ورک اسپیس مینجمنٹ پیج پر جائیں۔
- پر تشریف لے جائیں
{your_slack_domain}.slack.com/services/export
. - مطلوبہ تاریخ کی حد منتخب کریں اور برآمد شروع کریں۔
- ایکسپورٹ تیار ہونے کے بعد سلیک ای میل اور ڈی ایم کے ذریعے مطلع کرتا ہے۔
- برآمد کا نتیجہ a
.zip
آپ کے ڈاؤن لوڈز فولڈر یا آپ کے نامزد کردہ ڈاؤن لوڈ پاتھ میں موجود فائل۔ - ڈاؤن لوڈ کا راستہ تفویض کریں۔
.zip
فائل پرLOCAL_ZIPFILE
. - استعمال کریں
SlackDirectoryLoader
سےlangchain.document_loaders
پیکیج.
from langchain.document_loaders import SlackDirectoryLoader SLACK_WORKSPACE_URL = "https://xxx.slack.com" # Replace with your Slack URL
LOCAL_ZIPFILE = "" # Path to the Slack zip file loader = SlackDirectoryLoader(LOCAL_ZIPFILE, SLACK_WORKSPACE_URL)
docs = loader.load()
print(docs)
مثال II – فگما
فگما، انٹرفیس ڈیزائن کے لیے ایک مقبول ٹول، ڈیٹا انضمام کے لیے ایک REST API پیش کرتا ہے۔
- یو آر ایل فارمیٹ سے فگما فائل کی کلید حاصل کریں:
https://www.figma.com/file/{filekey}/sampleFilename
. - نوڈ IDs URL پیرامیٹر میں پائے جاتے ہیں۔
?node-id={node_id}
. - پر ہدایات کے بعد ایک رسائی ٹوکن بنائیں فگما ہیلپ سینٹر.
- ۔
FigmaFileLoader
سے کلاسlangchain.document_loaders.figma
فگما ڈیٹا لوڈ کرنے کے لیے استعمال کیا جاتا ہے۔ - مختلف LangChain ماڈیولز کی طرح
CharacterTextSplitter
,ChatOpenAI
وغیرہ، پروسیسنگ کے لیے ملازم ہیں۔
import os
from langchain.document_loaders.figma import FigmaFileLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.chat_models import ChatOpenAI
from langchain.indexes import VectorstoreIndexCreator
from langchain.chains import ConversationChain, LLMChain
from langchain.memory import ConversationBufferWindowMemory
from langchain.prompts.chat import ChatPromptTemplate, SystemMessagePromptTemplate, AIMessagePromptTemplate, HumanMessagePromptTemplate figma_loader = FigmaFileLoader( os.environ.get("ACCESS_TOKEN"), os.environ.get("NODE_IDS"), os.environ.get("FILE_KEY"),
) index = VectorstoreIndexCreator().from_loaders([figma_loader])
figma_doc_retriever = index.vectorstore.as_retriever()
- ۔
generate_code
فنکشن HTML/CSS کوڈ بنانے کے لیے فگما ڈیٹا کا استعمال کرتا ہے۔ - یہ ایک جی پی ٹی پر مبنی ماڈل کے ساتھ ایک ٹیمپلیٹڈ گفتگو کو ملازمت دیتا ہے۔
def generate_code(human_input): # Template for system and human prompts system_prompt_template = "Your coding instructions..." human_prompt_template = "Code the {text}. Ensure it's mobile responsive" # Creating prompt templates system_message_prompt = SystemMessagePromptTemplate.from_template(system_prompt_template) human_message_prompt = HumanMessagePromptTemplate.from_template(human_prompt_template) # Setting up the AI model gpt_4 = ChatOpenAI(temperature=0.02, model_name="gpt-4") # Retrieving relevant documents relevant_nodes = figma_doc_retriever.get_relevant_documents(human_input) # Generating and formatting the prompt conversation = [system_message_prompt, human_message_prompt] chat_prompt = ChatPromptTemplate.from_messages(conversation) response = gpt_4(chat_prompt.format_prompt(context=relevant_nodes, text=human_input).to_messages()) return response # Example usage
response = generate_code("page top header")
print(response.content)
- ۔
generate_code
فنکشن، جب عمل میں آتا ہے، فگما ڈیزائن ان پٹ کی بنیاد پر HTML/CSS کوڈ واپس کرتا ہے۔
آئیے اب اپنے علم کا استعمال کرتے ہوئے چند دستاویزی سیٹیں بنائیں۔
ہم سب سے پہلے پی ڈی ایف لوڈ کرتے ہیں، BCG سالانہ پائیداری رپورٹ۔
ہم اس کے لیے PyPDFLloader استعمال کرتے ہیں۔
from langchain.document_loaders import PyPDFLoader loader = PyPDFLoader("bcg-2022-annual-sustainability-report-apr-2023.pdf")
pdfpages = loader.load_and_split()
ہم اب ائیر ٹیبل سے ڈیٹا داخل کریں گے۔ ہمارے پاس ایک ایر ٹیبل ہے جس میں مختلف OCR اور ڈیٹا نکالنے کے ماڈلز کے بارے میں معلومات موجود ہیں -
آئیے اس کے لیے AirtableLoader استعمال کریں، جو مربوط لوڈرز کی فہرست میں پایا جاتا ہے۔
from langchain.document_loaders import AirtableLoader api_key = "XXXXX"
base_id = "XXXXX"
table_id = "XXXXX" loader = AirtableLoader(api_key, table_id, base_id)
airtabledocs = loader.load()
آئیے اب آگے بڑھتے ہیں اور سیکھتے ہیں کہ ان دستاویز کی کلاسوں کو کیسے استعمال کیا جائے۔
دستاویزی ٹرانسفارمرز
LangChain میں دستاویزی ٹرانسفارمرز دستاویزات میں ہیرا پھیری کے لیے ڈیزائن کیے گئے ضروری ٹولز ہیں، جنہیں ہم نے اپنے پچھلے سب سیکشن میں بنایا تھا۔
وہ طویل دستاویزات کو چھوٹے حصوں میں تقسیم کرنے، یکجا کرنے اور فلٹر کرنے جیسے کاموں کے لیے استعمال کیے جاتے ہیں، جو دستاویزات کو ماڈل کی سیاق و سباق کی کھڑکی کے مطابق ڈھالنے یا مخصوص درخواست کی ضروریات کو پورا کرنے کے لیے اہم ہیں۔
ایسا ہی ایک ٹول RecursiveCharacterTextSplitter ہے، ایک ورسٹائل ٹیکسٹ اسپلٹر جو تقسیم کے لیے کریکٹر لسٹ استعمال کرتا ہے۔ یہ پیرامیٹرز کی اجازت دیتا ہے جیسے حصہ کا سائز، اوورلیپ، اور انڈیکس شروع۔ Python میں اسے کس طرح استعمال کیا جاتا ہے اس کی ایک مثال یہ ہے:
from langchain.text_splitter import RecursiveCharacterTextSplitter state_of_the_union = "Your long text here..." text_splitter = RecursiveCharacterTextSplitter( chunk_size=100, chunk_overlap=20, length_function=len, add_start_index=True,
) texts = text_splitter.create_documents([state_of_the_union])
print(texts[0])
print(texts[1])
ایک اور ٹول CharacterTextSplitter ہے، جو متن کو ایک مخصوص کریکٹر کی بنیاد پر تقسیم کرتا ہے اور اس میں حصہ کے سائز اور اوورلیپ کے لیے کنٹرول شامل ہیں:
from langchain.text_splitter import CharacterTextSplitter text_splitter = CharacterTextSplitter( separator="nn", chunk_size=1000, chunk_overlap=200, length_function=len, is_separator_regex=False,
) texts = text_splitter.create_documents([state_of_the_union])
print(texts[0])
HTMLHeaderTextSplitter کو HTML مواد کو ہیڈر ٹیگز کی بنیاد پر تقسیم کرنے کے لیے ڈیزائن کیا گیا ہے، سیمنٹک ساخت کو برقرار رکھتے ہوئے:
from langchain.text_splitter import HTMLHeaderTextSplitter html_string = "Your HTML content here..."
headers_to_split_on = [("h1", "Header 1"), ("h2", "Header 2")] html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on)
html_header_splits = html_splitter.split_text(html_string)
print(html_header_splits[0])
HTMLHeaderTextSplitter کو دوسرے اسپلٹر کے ساتھ ملا کر ایک زیادہ پیچیدہ ہیرا پھیری حاصل کی جا سکتی ہے، جیسے Pipelined Splitter:
from langchain.text_splitter import HTMLHeaderTextSplitter, RecursiveCharacterTextSplitter url = "https://example.com"
headers_to_split_on = [("h1", "Header 1"), ("h2", "Header 2")]
html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on)
html_header_splits = html_splitter.split_text_from_url(url) chunk_size = 500
text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size)
splits = text_splitter.split_documents(html_header_splits)
print(splits[0])
LangChain مختلف پروگرامنگ زبانوں کے لیے مخصوص سپلٹرز بھی پیش کرتا ہے، جیسے Python Code Splitter اور JavaScript Code Splitter:
from langchain.text_splitter import RecursiveCharacterTextSplitter, Language python_code = """
def hello_world(): print("Hello, World!")
hello_world() """ python_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.PYTHON, chunk_size=50
)
python_docs = python_splitter.create_documents([python_code])
print(python_docs[0]) js_code = """
function helloWorld() { console.log("Hello, World!");
}
helloWorld(); """ js_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.JS, chunk_size=60
)
js_docs = js_splitter.create_documents([js_code])
print(js_docs[0])
ٹوکن کی گنتی کی بنیاد پر متن کو تقسیم کرنے کے لیے، جو ٹوکن کی حدود کے ساتھ زبان کے ماڈلز کے لیے مفید ہے، TokenTextSplitter استعمال کیا جاتا ہے:
from langchain.text_splitter import TokenTextSplitter text_splitter = TokenTextSplitter(chunk_size=10)
texts = text_splitter.split_text(state_of_the_union)
print(texts[0])
آخر میں، LongContextReorder طویل سیاق و سباق کی وجہ سے ماڈلز میں کارکردگی میں کمی کو روکنے کے لیے دستاویزات کو دوبارہ ترتیب دیتا ہے:
from langchain.document_transformers import LongContextReorder reordering = LongContextReorder()
reordered_docs = reordering.transform_documents(docs)
print(reordered_docs[0])
یہ ٹولز LangChain میں دستاویزات کو تبدیل کرنے کے مختلف طریقوں کو ظاہر کرتے ہیں، سادہ متن کی تقسیم سے لے کر پیچیدہ دوبارہ ترتیب دینے اور زبان کے ساتھ مخصوص تقسیم تک۔ مزید گہرائی اور مخصوص استعمال کے معاملات کے لیے، LangChain دستاویزات اور انضمام کے سیکشن سے مشورہ کیا جانا چاہیے۔
ہماری مثالوں میں، لوڈرز نے پہلے ہی ہمارے لیے کٹے ہوئے دستاویزات بنا لیے ہیں، اور یہ حصہ پہلے ہی سنبھالا جا چکا ہے۔
ٹیکسٹ ایمبیڈنگ ماڈلز
LangChain میں ٹیکسٹ ایمبیڈنگ ماڈلز مختلف ایمبیڈنگ ماڈل فراہم کنندگان جیسے OpenAI، Cohere، اور Hugging Face کے لیے ایک معیاری انٹرفیس فراہم کرتے ہیں۔ یہ ماڈل متن کو ویکٹر کی نمائندگی میں تبدیل کرتے ہیں، ویکٹر اسپیس میں متن کی مماثلت کے ذریعے سیمنٹک تلاش جیسے کاموں کو فعال کرتے ہیں۔
ٹیکسٹ ایمبیڈنگ ماڈلز کے ساتھ شروع کرنے کے لیے، آپ کو عام طور پر مخصوص پیکجز انسٹال کرنے اور API کیز سیٹ کرنے کی ضرورت ہوتی ہے۔ ہم نے یہ پہلے ہی OpenAI کے لیے کیا ہے۔
LangChain میں، embed_documents
طریقہ متعدد متنوں کو سرایت کرنے کے لیے استعمال کیا جاتا ہے، جو ویکٹر کی نمائندگی کی فہرست فراہم کرتا ہے۔ مثال کے طور پر:
from langchain.embeddings import OpenAIEmbeddings # Initialize the model
embeddings_model = OpenAIEmbeddings() # Embed a list of texts
embeddings = embeddings_model.embed_documents( ["Hi there!", "Oh, hello!", "What's your name?", "My friends call me World", "Hello World!"]
)
print("Number of documents embedded:", len(embeddings))
print("Dimension of each embedding:", len(embeddings[0]))
کسی ایک متن کو سرایت کرنے کے لیے، جیسے کہ تلاش کا سوال، embed_query
طریقہ استعمال کیا جاتا ہے. یہ دستاویز ایمبیڈنگس کے سیٹ سے سوال کا موازنہ کرنے کے لیے مفید ہے۔ مثال کے طور پر:
from langchain.embeddings import OpenAIEmbeddings # Initialize the model
embeddings_model = OpenAIEmbeddings() # Embed a single query
embedded_query = embeddings_model.embed_query("What was the name mentioned in the conversation?")
print("First five dimensions of the embedded query:", embedded_query[:5])
ان ایمبیڈنگز کو سمجھنا بہت ضروری ہے۔ متن کا ہر ٹکڑا ایک ویکٹر میں تبدیل ہوتا ہے، جس کا طول و عرض استعمال شدہ ماڈل پر منحصر ہوتا ہے۔ مثال کے طور پر، OpenAI ماڈلز عام طور پر 1536 جہتی ویکٹر تیار کرتے ہیں۔ ان ایمبیڈنگز کو پھر متعلقہ معلومات کی بازیافت کے لیے استعمال کیا جاتا ہے۔
LangChain کی سرایت کرنے کی فعالیت صرف OpenAI تک محدود نہیں ہے بلکہ اسے مختلف فراہم کنندگان کے ساتھ کام کرنے کے لیے ڈیزائن کیا گیا ہے۔ سیٹ اپ اور استعمال فراہم کنندہ کے لحاظ سے تھوڑا سا مختلف ہو سکتا ہے، لیکن ویکٹر اسپیس میں متن کو سرایت کرنے کا بنیادی تصور وہی رہتا ہے۔ تفصیلی استعمال کے لیے، بشمول ایڈوانس کنفیگریشنز اور مختلف ایمبیڈنگ ماڈل فراہم کنندگان کے ساتھ انضمام کے لیے، Integrations سیکشن میں LangChain دستاویزات ایک قیمتی وسیلہ ہے۔
ویکٹر اسٹورز
LangChain میں ویکٹر اسٹورز موثر اسٹوریج اور ٹیکسٹ ایمبیڈنگز کی تلاش کی حمایت کرتے ہیں۔ LangChain 50 سے زیادہ ویکٹر اسٹورز کے ساتھ مربوط ہے، استعمال میں آسانی کے لیے ایک معیاری انٹرفیس فراہم کرتا ہے۔
مثال: ایمبیڈنگز کو ذخیرہ کرنا اور تلاش کرنا
متن کو سرایت کرنے کے بعد، ہم انہیں ویکٹر اسٹور میں اسٹور کرسکتے ہیں جیسے Chroma
اور مماثلت کی تلاش کریں:
from langchain.vectorstores import Chroma db = Chroma.from_texts(embedded_texts)
similar_texts = db.similarity_search("search query")
آئیے متبادل طور پر FAISS ویکٹر سٹور کو اپنی دستاویزات کے لیے انڈیکس بنانے کے لیے استعمال کریں۔
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS pdfstore = FAISS.from_documents(pdfpages, embedding=OpenAIEmbeddings()) airtablestore = FAISS.from_documents(airtabledocs, embedding=OpenAIEmbeddings())
بازیافت کرنے والے
LangChain میں بازیافت کرنے والے انٹرفیس ہیں جو غیر ساختہ استفسار کے جواب میں دستاویزات واپس کرتے ہیں۔ وہ ویکٹر اسٹورز سے زیادہ عام ہیں، ذخیرہ کرنے کے بجائے بازیافت پر توجہ مرکوز کرتے ہیں۔ اگرچہ ویکٹر اسٹورز کو بازیافت کرنے والے کی ریڑھ کی ہڈی کے طور پر استعمال کیا جا سکتا ہے، اس کے ساتھ ساتھ بازیافت کی دوسری قسمیں بھی ہیں۔
کروما ریٹریور سیٹ اپ کرنے کے لیے، آپ پہلے اسے استعمال کرکے انسٹال کریں۔ pip install chromadb
. پھر، آپ Python کمانڈز کی ایک سیریز کا استعمال کرتے ہوئے دستاویزات کو لوڈ، تقسیم، ایمبیڈ اور بازیافت کرتے ہیں۔ Chroma retriever کو ترتیب دینے کے لیے یہاں ایک کوڈ کی مثال ہے:
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma full_text = open("state_of_the_union.txt", "r").read()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
texts = text_splitter.split_text(full_text) embeddings = OpenAIEmbeddings()
db = Chroma.from_texts(texts, embeddings)
retriever = db.as_retriever() retrieved_docs = retriever.invoke("What did the president say about Ketanji Brown Jackson?")
print(retrieved_docs[0].page_content)
MultiQueryRetriever صارف کے ان پٹ استفسار کے لیے متعدد سوالات پیدا کرکے اور نتائج کو یکجا کرکے فوری ٹیوننگ کو خودکار کرتا ہے۔ یہاں اس کے سادہ استعمال کی ایک مثال ہے:
from langchain.chat_models import ChatOpenAI
from langchain.retrievers.multi_query import MultiQueryRetriever question = "What are the approaches to Task Decomposition?"
llm = ChatOpenAI(temperature=0)
retriever_from_llm = MultiQueryRetriever.from_llm( retriever=db.as_retriever(), llm=llm
) unique_docs = retriever_from_llm.get_relevant_documents(query=question)
print("Number of unique documents:", len(unique_docs))
LangChain میں سیاق و سباق کا کمپریشن استفسار کے سیاق و سباق کا استعمال کرتے ہوئے بازیافت شدہ دستاویزات کو کمپریس کرتا ہے، اس بات کو یقینی بناتے ہوئے کہ صرف متعلقہ معلومات کی واپسی کی جائے۔ اس میں مواد میں کمی اور کم متعلقہ دستاویزات کو فلٹر کرنا شامل ہے۔ درج ذیل کوڈ کی مثال دکھاتی ہے کہ سیاق و سباق کے کمپریشن ریٹریور کو کیسے استعمال کیا جائے:
from langchain.llms import OpenAI
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor llm = OpenAI(temperature=0)
compressor = LLMChainExtractor.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(base_compressor=compressor, base_retriever=retriever) compressed_docs = compression_retriever.get_relevant_documents("What did the president say about Ketanji Jackson Brown")
print(compressed_docs[0].page_content)
EnsembleRetriever بہتر کارکردگی حاصل کرنے کے لیے مختلف بازیافت الگورتھم کو یکجا کرتا ہے۔ BM25 اور FAISS Retrievers کو ملانے کی ایک مثال درج ذیل کوڈ میں دکھائی گئی ہے۔
from langchain.retrievers import BM25Retriever, EnsembleRetriever
from langchain.vectorstores import FAISS bm25_retriever = BM25Retriever.from_texts(doc_list).set_k(2)
faiss_vectorstore = FAISS.from_texts(doc_list, OpenAIEmbeddings())
faiss_retriever = faiss_vectorstore.as_retriever(search_kwargs={"k": 2}) ensemble_retriever = EnsembleRetriever( retrievers=[bm25_retriever, faiss_retriever], weights=[0.5, 0.5]
) docs = ensemble_retriever.get_relevant_documents("apples")
print(docs[0].page_content)
LangChain میں ملٹی ویکٹر ریٹریور ہر دستاویز میں متعدد ویکٹرز کے ساتھ دستاویزات سے استفسار کرنے کی اجازت دیتا ہے، جو ایک دستاویز کے اندر مختلف سیمنٹک پہلوؤں کو کیپچر کرنے کے لیے مفید ہے۔ متعدد ویکٹر بنانے کے طریقوں میں چھوٹے حصوں میں تقسیم کرنا، خلاصہ کرنا، یا فرضی سوالات پیدا کرنا شامل ہیں۔ دستاویزات کو چھوٹے ٹکڑوں میں تقسیم کرنے کے لیے، درج ذیل Python کوڈ استعمال کیا جا سکتا ہے:
python
from langchain.retrievers.multi_vector import MultiVectorRetriever
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.storage import InMemoryStore
from langchain.document_loaders from TextLoader
import uuid loaders = [TextLoader("file1.txt"), TextLoader("file2.txt")]
docs = [doc for loader in loaders for doc in loader.load()]
text_splitter = RecursiveCharacterTextSplitter(chunk_size=10000)
docs = text_splitter.split_documents(docs) vectorstore = Chroma(collection_name="full_documents", embedding_function=OpenAIEmbeddings())
store = InMemoryStore()
id_key = "doc_id"
retriever = MultiVectorRetriever(vectorstore=vectorstore, docstore=store, id_key=id_key) doc_ids = [str(uuid.uuid4()) for _ in docs]
child_text_splitter = RecursiveCharacterTextSplitter(chunk_size=400)
sub_docs = [sub_doc for doc in docs for sub_doc in child_text_splitter.split_documents([doc])]
for sub_doc in sub_docs: sub_doc.metadata[id_key] = doc_ids[sub_docs.index(sub_doc)] retriever.vectorstore.add_documents(sub_docs)
retriever.docstore.mset(list(zip(doc_ids, docs)))
زیادہ توجہ مرکوز مواد کی نمائندگی کی وجہ سے بہتر بازیافت کے لیے خلاصے تیار کرنا ایک اور طریقہ ہے۔ خلاصہ تیار کرنے کی ایک مثال یہ ہے:
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.document import Document chain = (lambda x: x.page_content) | ChatPromptTemplate.from_template("Summarize the following document:nn{doc}") | ChatOpenAI(max_retries=0) | StrOutputParser()
summaries = chain.batch(docs, {"max_concurrency": 5}) summary_docs = [Document(page_content=s, metadata={id_key: doc_ids[i]}) for i, s in enumerate(summaries)]
retriever.vectorstore.add_documents(summary_docs)
retriever.docstore.mset(list(zip(doc_ids, docs)))
LLM کا استعمال کرتے ہوئے ہر دستاویز سے متعلقہ فرضی سوالات پیدا کرنا ایک اور طریقہ ہے۔ یہ مندرجہ ذیل کوڈ کے ساتھ کیا جا سکتا ہے:
functions = [{"name": "hypothetical_questions", "parameters": {"questions": {"type": "array", "items": {"type": "string"}}}}]
from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser chain = (lambda x: x.page_content) | ChatPromptTemplate.from_template("Generate 3 hypothetical questions:nn{doc}") | ChatOpenAI(max_retries=0).bind(functions=functions, function_call={"name": "hypothetical_questions"}) | JsonKeyOutputFunctionsParser(key_name="questions")
hypothetical_questions = chain.batch(docs, {"max_concurrency": 5}) question_docs = [Document(page_content=q, metadata={id_key: doc_ids[i]}) for i, questions in enumerate(hypothetical_questions) for q in questions]
retriever.vectorstore.add_documents(question_docs)
retriever.docstore.mset(list(zip(doc_ids, docs)))
پیرنٹ ڈاکومنٹ ریٹریور ایک اور بازیافت ہے جو چھوٹے حصوں کو ذخیرہ کرکے اور ان کے بڑے پیرنٹ دستاویزات کو بازیافت کرکے سرایت کی درستگی اور سیاق و سباق کو برقرار رکھنے کے درمیان توازن قائم کرتا ہے۔ اس کا نفاذ حسب ذیل ہے:
from langchain.retrievers import ParentDocumentRetriever loaders = [TextLoader("file1.txt"), TextLoader("file2.txt")]
docs = [doc for loader in loaders for doc in loader.load()] child_splitter = RecursiveCharacterTextSplitter(chunk_size=400)
vectorstore = Chroma(collection_name="full_documents", embedding_function=OpenAIEmbeddings())
store = InMemoryStore()
retriever = ParentDocumentRetriever(vectorstore=vectorstore, docstore=store, child_splitter=child_splitter) retriever.add_documents(docs, ids=None) retrieved_docs = retriever.get_relevant_documents("query")
ایک خود سے استفسار کرنے والا بازیافت قدرتی زبان کے آدانوں سے ساختی سوالات تیار کرتا ہے اور انہیں اپنے بنیادی ویکٹر اسٹور پر لاگو کرتا ہے۔ اس کا نفاذ درج ذیل کوڈ میں دکھایا گیا ہے۔
from langchain.chat_models from ChatOpenAI
from langchain.chains.query_constructor.base from AttributeInfo
from langchain.retrievers.self_query.base from SelfQueryRetriever metadata_field_info = [AttributeInfo(name="genre", description="...", type="string"), ...]
document_content_description = "Brief summary of a movie"
llm = ChatOpenAI(temperature=0) retriever = SelfQueryRetriever.from_llm(llm, vectorstore, document_content_description, metadata_field_info) retrieved_docs = retriever.invoke("query")
WebResearchRetriever دیے گئے سوال کی بنیاد پر ویب تحقیق کرتا ہے -
from langchain.retrievers.web_research import WebResearchRetriever # Initialize components
llm = ChatOpenAI(temperature=0)
search = GoogleSearchAPIWrapper()
vectorstore = Chroma(embedding_function=OpenAIEmbeddings()) # Instantiate WebResearchRetriever
web_research_retriever = WebResearchRetriever.from_llm(vectorstore=vectorstore, llm=llm, search=search) # Retrieve documents
docs = web_research_retriever.get_relevant_documents("query")
ہماری مثالوں کے لیے، ہم اپنے ویکٹر سٹور آبجیکٹ کے حصے کے طور پر پہلے سے نافذ کردہ معیاری بازیافت کا استعمال بھی کر سکتے ہیں
اب ہم بازیافت کرنے والوں سے استفسار کر سکتے ہیں۔ ہمارے استفسار کا آؤٹ پٹ استفسار سے متعلقہ دستاویزی اشیاء ہوگا۔ یہ بالآخر مزید حصوں میں متعلقہ جوابات تخلیق کرنے کے لیے استعمال کیے جائیں گے۔
ہمارے AI سے چلنے والے ورک فلو بلڈر کے ساتھ دستی کاموں اور ورک فلو کو خودکار بنائیں، جسے Nanonets نے آپ اور آپ کی ٹیموں کے لیے ڈیزائن کیا ہے۔
ماڈیول III: ایجنٹ
LangChain "Agents" کے نام سے ایک طاقتور تصور متعارف کراتا ہے جو زنجیروں کے خیال کو بالکل نئی سطح پر لے جاتا ہے۔ ایجنٹ زبان کے ماڈلز کو متحرک طور پر انجام دینے کے لیے کارروائیوں کے سلسلے کا تعین کرنے کے لیے فائدہ اٹھاتے ہیں، انھیں ناقابل یقین حد تک ہمہ گیر اور موافق بناتے ہیں۔ روایتی زنجیروں کے برعکس، جہاں کارروائیوں کو کوڈ میں سخت کوڈ کیا جاتا ہے، ایجنٹ زبان کے ماڈلز کو استدلال کے انجن کے طور پر استعمال کرتے ہیں تاکہ یہ فیصلہ کیا جا سکے کہ کون سی کارروائیاں اور کس ترتیب میں کی جائیں۔
ایجنٹ فیصلہ سازی کے لیے ذمہ دار بنیادی جز ہے۔ یہ زبان کے ماڈل کی طاقت اور کسی خاص مقصد کو حاصل کرنے کے لیے اگلے اقدامات کا تعین کرنے کے لیے فوری طور پر استعمال کرتا ہے۔ ایجنٹ کو دیے جانے والے آدانوں میں عام طور پر شامل ہیں:
- ، فورم کے اوزار: دستیاب ٹولز کی تفصیل (اس پر مزید بعد میں)۔
- یوزر ان پٹ: صارف کی طرف سے اعلیٰ سطح کا مقصد یا استفسار۔
- درمیانی مراحل: موجودہ صارف کے ان پٹ تک پہنچنے کے لیے (ایکشن، ٹول آؤٹ پٹ) جوڑوں کی تاریخ۔
ایک ایجنٹ کی پیداوار اگلی ہو سکتی ہے۔ کارروائی اقدامات کرنا (ایجنٹ ایکشنز) یا فائنل جواب صارف کو بھیجنے کے لیے (ایجنٹ فنش). ایک کارروائی وضاحت کرتا ہے a کے آلے اور ان پٹ اس آلے کے لئے.
آلات
ٹولز ایسے انٹرفیس ہیں جنہیں ایک ایجنٹ دنیا کے ساتھ بات چیت کرنے کے لیے استعمال کر سکتا ہے۔ وہ ایجنٹوں کو مختلف کام انجام دینے کے قابل بناتے ہیں، جیسے ویب کو تلاش کرنا، شیل کمانڈز چلانا، یا بیرونی APIs تک رسائی حاصل کرنا۔ LangChain میں، ایجنٹوں کی صلاحیتوں کو بڑھانے اور انہیں متنوع کاموں کو پورا کرنے کے قابل بنانے کے لیے اوزار ضروری ہیں۔
LangChain میں ٹولز استعمال کرنے کے لیے، آپ انہیں مندرجہ ذیل ٹکڑا استعمال کر کے لوڈ کر سکتے ہیں۔
from langchain.agents import load_tools tool_names = [...]
tools = load_tools(tool_names)
کچھ ٹولز کو شروع کرنے کے لیے بیس لینگویج ماڈل (LLM) کی ضرورت پڑ سکتی ہے۔ ایسے معاملات میں، آپ ایل ایل ایم بھی پاس کر سکتے ہیں:
from langchain.agents import load_tools tool_names = [...]
llm = ...
tools = load_tools(tool_names, llm=llm)
یہ سیٹ اپ آپ کو مختلف ٹولز تک رسائی حاصل کرنے اور انہیں اپنے ایجنٹ کے ورک فلو میں ضم کرنے کی اجازت دیتا ہے۔ استعمال کی دستاویزات کے ساتھ ٹولز کی مکمل فہرست ہے۔ یہاں.
آئیے ٹولز کی کچھ مثالیں دیکھیں۔
DuckDuckGo
DuckDuckGo ٹول آپ کو اس کے سرچ انجن کا استعمال کرتے ہوئے ویب تلاش کرنے کے قابل بناتا ہے۔ اسے استعمال کرنے کا طریقہ یہاں ہے:
from langchain.tools import DuckDuckGoSearchRun
search = DuckDuckGoSearchRun()
search.run("manchester united vs luton town match summary")
DataForSeo
DataForSeo ٹول کٹ آپ کو DataForSeo API کا استعمال کرتے ہوئے سرچ انجن کے نتائج حاصل کرنے کی اجازت دیتی ہے۔ اس ٹول کٹ کو استعمال کرنے کے لیے، آپ کو اپنے API اسناد کو ترتیب دینے کی ضرورت ہوگی۔ اسناد کو ترتیب دینے کا طریقہ یہاں ہے:
import os os.environ["DATAFORSEO_LOGIN"] = "<your_api_access_username>"
os.environ["DATAFORSEO_PASSWORD"] = "<your_api_access_password>"
ایک بار جب آپ کی اسناد سیٹ ہو جائیں، آپ ایک بنا سکتے ہیں۔ DataForSeoAPIWrapper
API تک رسائی کے لیے ٹول:
from langchain.utilities.dataforseo_api_search import DataForSeoAPIWrapper wrapper = DataForSeoAPIWrapper() result = wrapper.run("Weather in Los Angeles")
۔ DataForSeoAPIWrapper
ٹول سرچ انجن کے نتائج کو مختلف ذرائع سے بازیافت کرتا ہے۔
آپ JSON جواب میں واپس کیے گئے نتائج اور فیلڈز کی قسم کو حسب ضرورت بنا سکتے ہیں۔ مثال کے طور پر، آپ نتائج کی اقسام، فیلڈز کی وضاحت کر سکتے ہیں، اور واپس آنے کے لیے سرفہرست نتائج کی تعداد کے لیے زیادہ سے زیادہ گنتی سیٹ کر سکتے ہیں:
json_wrapper = DataForSeoAPIWrapper( json_result_types=["organic", "knowledge_graph", "answer_box"], json_result_fields=["type", "title", "description", "text"], top_count=3,
) json_result = json_wrapper.results("Bill Gates")
یہ مثال نتائج کی اقسام، فیلڈز، اور نتائج کی تعداد کو محدود کرکے JSON جواب کو حسب ضرورت بناتی ہے۔
آپ API ریپر کو اضافی پیرامیٹرز دے کر اپنے تلاش کے نتائج کے لیے مقام اور زبان بھی بتا سکتے ہیں:
customized_wrapper = DataForSeoAPIWrapper( top_count=10, json_result_types=["organic", "local_pack"], json_result_fields=["title", "description", "type"], params={"location_name": "Germany", "language_code": "en"},
) customized_result = customized_wrapper.results("coffee near me")
مقام اور زبان کے پیرامیٹرز فراہم کرکے، آپ اپنے تلاش کے نتائج کو مخصوص علاقوں اور زبانوں کے مطابق بنا سکتے ہیں۔
آپ جس سرچ انجن کو استعمال کرنا چاہتے ہیں اسے منتخب کرنے کے لیے آپ کے پاس لچک ہے۔ بس مطلوبہ سرچ انجن کی وضاحت کریں:
customized_wrapper = DataForSeoAPIWrapper( top_count=10, json_result_types=["organic", "local_pack"], json_result_fields=["title", "description", "type"], params={"location_name": "Germany", "language_code": "en", "se_name": "bing"},
) customized_result = customized_wrapper.results("coffee near me")
اس مثال میں، تلاش کو بنگ کو بطور سرچ انجن استعمال کرنے کے لیے اپنی مرضی کے مطابق بنایا گیا ہے۔
API ریپر آپ کو اس قسم کی تلاش کی وضاحت کرنے کی بھی اجازت دیتا ہے جسے آپ انجام دینا چاہتے ہیں۔ مثال کے طور پر، آپ نقشے کی تلاش کر سکتے ہیں:
maps_search = DataForSeoAPIWrapper( top_count=10, json_result_fields=["title", "value", "address", "rating", "type"], params={ "location_coordinate": "52.512,13.36,12z", "language_code": "en", "se_type": "maps", },
) maps_search_result = maps_search.results("coffee near me")
یہ نقشے سے متعلق معلومات کو بازیافت کرنے کے لیے تلاش کو حسب ضرورت بناتا ہے۔
شیل (بش)
شیل ٹول کٹ ایجنٹوں کو شیل ماحول تک رسائی فراہم کرتی ہے، جس سے وہ شیل کمانڈز پر عمل درآمد کر سکتے ہیں۔ یہ خصوصیت طاقتور ہے لیکن احتیاط کے ساتھ استعمال کی جانی چاہیے، خاص طور پر سینڈ باکس والے ماحول میں۔ یہاں یہ ہے کہ آپ شیل ٹول کو کس طرح استعمال کرسکتے ہیں:
from langchain.tools import ShellTool shell_tool = ShellTool() result = shell_tool.run({"commands": ["echo 'Hello World!'", "time"]})
اس مثال میں، شیل ٹول دو شیل کمانڈ چلاتا ہے: "ہیلو ورلڈ!" کی بازگشت۔ اور موجودہ وقت کی نمائش۔
آپ زیادہ پیچیدہ کام انجام دینے کے لیے ایجنٹ کو شیل ٹول فراہم کر سکتے ہیں۔ شیل ٹول کا استعمال کرتے ہوئے ویب صفحہ سے لنکس لانے والے ایجنٹ کی ایک مثال یہ ہے۔
from langchain.agents import AgentType, initialize_agent
from langchain.chat_models import ChatOpenAI llm = ChatOpenAI(temperature=0.1) shell_tool.description = shell_tool.description + f"args {shell_tool.args}".replace( "{", "{{"
).replace("}", "}}")
self_ask_with_search = initialize_agent( [shell_tool], llm, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
self_ask_with_search.run( "Download the langchain.com webpage and grep for all urls. Return only a sorted list of them. Be sure to use double quotes."
)
اس منظر نامے میں، ایجنٹ شیل ٹول کا استعمال کرتا ہے تاکہ ویب صفحہ سے یو آر ایل کو بازیافت، فلٹر اور ترتیب دینے کے لیے حکموں کی ترتیب کو عمل میں لایا جا سکے۔
فراہم کردہ مثالیں LangChain میں دستیاب کچھ ٹولز کو ظاہر کرتی ہیں۔ یہ ٹولز بالآخر ایجنٹوں کی صلاحیتوں کو بڑھاتے ہیں (اگلے ذیلی حصے میں دریافت کیا گیا ہے) اور انہیں مختلف کاموں کو مؤثر طریقے سے انجام دینے کے لیے بااختیار بناتے ہیں۔ آپ کی ضروریات پر منحصر ہے، آپ ایسے ٹولز اور ٹول کٹس کا انتخاب کر سکتے ہیں جو آپ کے پروجیکٹ کی ضروریات کے مطابق ہوں اور انہیں اپنے ایجنٹ کے ورک فلو میں ضم کر سکیں۔
ایجنٹوں پر واپس جائیں۔
آئیے اب ایجنٹوں کی طرف چلتے ہیں۔
AgentExecutor ایک ایجنٹ کے لیے رن ٹائم ماحول ہے۔ یہ ایجنٹ کو کال کرنے، اس کے منتخب کردہ اعمال کو انجام دینے، کارروائی کے نتائج کو ایجنٹ کو واپس کرنے، اور ایجنٹ کے مکمل ہونے تک اس عمل کو دہرانے کا ذمہ دار ہے۔ سیڈوکوڈ میں، AgentExecutor کچھ اس طرح نظر آ سکتا ہے:
next_action = agent.get_action(...)
while next_action != AgentFinish: observation = run(next_action) next_action = agent.get_action(..., next_action, observation)
return next_action
AgentExecutor مختلف پیچیدگیوں کو ہینڈل کرتا ہے، جیسے کہ ایسے معاملات سے نمٹنا جہاں ایجنٹ غیر موجود ٹول کا انتخاب کرتا ہے، ٹول کی غلطیوں کو ہینڈل کرتا ہے، ایجنٹ سے تیار کردہ آؤٹ پٹ کا انتظام کرتا ہے، اور تمام سطحوں پر لاگنگ اور مشاہدہ فراہم کرتا ہے۔
جبکہ AgentExecutor کلاس LangChain میں بنیادی ایجنٹ رن ٹائم ہے، وہاں دیگر، زیادہ تجرباتی رن ٹائمز کی حمایت کی گئی ہے، بشمول:
- منصوبہ بندی اور عمل کرنے والا ایجنٹ
- بیبی اے جی آئی
- آٹو جی پی ٹی
ایجنٹ کے فریم ورک کی بہتر تفہیم حاصل کرنے کے لیے، آئیے شروع سے ایک بنیادی ایجنٹ بنائیں، اور پھر پہلے سے تیار کردہ ایجنٹوں کو تلاش کرنے کے لیے آگے بڑھیں۔
اس سے پہلے کہ ہم ایجنٹ کی تعمیر میں غوطہ لگائیں، کچھ کلیدی اصطلاحات اور اسکیما پر نظر ثانی کرنا ضروری ہے:
- ایجنٹ ایکشن: یہ ایک ڈیٹا کلاس ہے جس کی نمائندگی ایک ایجنٹ کو کرنی چاہیے۔ یہ ایک پر مشتمل ہے۔
tool
پراپرٹی (دعا کرنے کے آلے کا نام) اور atool_input
پراپرٹی (اس ٹول کے لیے ان پٹ)۔ - ایجنٹ ختم: یہ ڈیٹا کلاس اشارہ کرتی ہے کہ ایجنٹ نے اپنا کام مکمل کر لیا ہے اور اسے صارف کو جواب واپس کرنا چاہیے۔ اس میں عام طور پر واپسی کی قدروں کی ایک لغت شامل ہوتی ہے، اکثر جوابی متن پر مشتمل کلیدی "آؤٹ پٹ" کے ساتھ۔
- درمیانی مراحل: یہ پچھلی ایجنٹ کی کارروائیوں اور متعلقہ نتائج کے ریکارڈ ہیں۔ وہ ایجنٹ کے مستقبل کے تکرار کے سیاق و سباق کو منتقل کرنے کے لیے اہم ہیں۔
ہماری مثال میں، ہم اپنا ایجنٹ بنانے کے لیے OpenAI فنکشن کالنگ کا استعمال کریں گے۔ یہ نقطہ نظر ایجنٹ کی تخلیق کے لیے قابل اعتماد ہے۔ ہم ایک سادہ ٹول بنا کر شروع کریں گے جو کسی لفظ کی لمبائی کا حساب لگاتا ہے۔ یہ ٹول مفید ہے کیونکہ زبان کے ماڈل بعض اوقات الفاظ کی لمبائی گنتے وقت ٹوکنائزیشن کی وجہ سے غلطیاں کر سکتے ہیں۔
سب سے پہلے، آئیے اس زبان کا ماڈل لوڈ کریں جسے ہم ایجنٹ کو کنٹرول کرنے کے لیے استعمال کریں گے:
from langchain.chat_models import ChatOpenAI llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
آئیے ماڈل کو لفظ کی لمبائی کے حساب سے جانچتے ہیں:
llm.invoke("how many letters in the word educa?")
جواب میں لفظ "educa" میں حروف کی تعداد کی نشاندہی کرنی چاہیے۔
اگلا، ہم ایک لفظ کی لمبائی کا حساب لگانے کے لیے ایک سادہ Python فنکشن کی وضاحت کریں گے:
from langchain.agents import tool @tool
def get_word_length(word: str) -> int: """Returns the length of a word.""" return len(word)
ہم نے ایک ٹول بنایا ہے جس کا نام ہے۔ get_word_length
جو ایک لفظ کو بطور ان پٹ لیتا ہے اور اس کی لمبائی لوٹاتا ہے۔
اب، آئیے ایجنٹ کے لیے پرامپٹ بنائیں۔ پرامپٹ ایجنٹ کو ہدایت کرتا ہے کہ آؤٹ پٹ کو استدلال اور فارمیٹ کرنے کا طریقہ۔ ہمارے معاملے میں، ہم OpenAI فنکشن کالنگ استعمال کر رہے ہیں، جس کے لیے کم سے کم ہدایات درکار ہیں۔ ہم صارف کے ان پٹ اور ایجنٹ سکریچ پیڈ کے لیے پلیس ہولڈرز کے ساتھ پرامپٹ کی وضاحت کریں گے:
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder prompt = ChatPromptTemplate.from_messages( [ ( "system", "You are a very powerful assistant but not great at calculating word lengths.", ), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ]
)
اب، ایجنٹ کو کیسے پتہ چلے گا کہ وہ کون سے اوزار استعمال کر سکتا ہے؟ ہم OpenAI فنکشن کالنگ لینگوئج ماڈلز پر انحصار کر رہے ہیں، جس کے لیے فنکشنز کو الگ سے پاس کرنے کی ضرورت ہوتی ہے۔ ایجنٹ کو اپنے ٹولز فراہم کرنے کے لیے، ہم انہیں OpenAI فنکشن کالز کے طور پر فارمیٹ کریں گے:
from langchain.tools.render import format_tool_to_openai_function llm_with_tools = llm.bind(functions=[format_tool_to_openai_function(t) for t in tools])
اب، ہم ان پٹ میپنگ کی وضاحت کرکے اور اجزاء کو جوڑ کر ایجنٹ بنا سکتے ہیں:
یہ LCEL زبان ہے۔ اس پر ہم بعد میں تفصیل سے بات کریں گے۔
from langchain.agents.format_scratchpad import format_to_openai_function_messages
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai _function_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser()
)
ہم نے اپنا ایجنٹ بنایا ہے، جو صارف کے ان پٹ کو سمجھتا ہے، دستیاب ٹولز کا استعمال کرتا ہے اور آؤٹ پٹ کو فارمیٹ کرتا ہے۔ اب، اس کے ساتھ بات چیت کرتے ہیں:
agent.invoke({"input": "how many letters in the word educa?", "intermediate_steps": []})
ایجنٹ کو AgentAction کے ساتھ جواب دینا چاہیے، جس میں اگلی کارروائی کی جائے گی۔
ہم نے ایجنٹ بنا لیا ہے، لیکن اب ہمیں اس کے لیے رن ٹائم لکھنے کی ضرورت ہے۔ سب سے آسان رن ٹائم وہ ہے جو ایجنٹ کو مسلسل کال کرتا ہے، کارروائیاں کرتا ہے، اور ایجنٹ کے ختم ہونے تک دہرایا جاتا ہے۔ یہاں ایک مثال ہے:
from langchain.schema.agent import AgentFinish user_input = "how many letters in the word educa?"
intermediate_steps = [] while True: output = agent.invoke( { "input": user_input, "intermediate_steps": intermediate_steps, } ) if isinstance(output, AgentFinish): final_result = output.return_values["output"] break else: print(f"TOOL NAME: {output.tool}") print(f"TOOL INPUT: {output.tool_input}") tool = {"get_word_length": get_word_length}[output.tool] observation = tool.run(output.tool_input) intermediate_steps.append((output, observation)) print(final_result)
اس لوپ میں، ہم بار بار ایجنٹ کو کال کرتے ہیں، کارروائیاں کرتے ہیں، اور ایجنٹ کے مکمل ہونے تک درمیانی مراحل کو اپ ڈیٹ کرتے ہیں۔ ہم لوپ کے اندر ٹول کے تعاملات کو بھی ہینڈل کرتے ہیں۔
اس عمل کو آسان بنانے کے لیے، LangChain AgentExecutor کلاس فراہم کرتا ہے، جو ایجنٹ کے عمل کو سمیٹتا ہے اور غلطی سے نمٹنے، جلد روکنے، ٹریسنگ، اور دیگر بہتری پیش کرتا ہے۔ آئیے ایجنٹ کے ساتھ بات چیت کرنے کے لیے AgentExecutor کا استعمال کریں:
from langchain.agents import AgentExecutor agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) agent_executor.invoke({"input": "how many letters in the word educa?"})
AgentExecutor عملدرآمد کے عمل کو آسان بناتا ہے اور ایجنٹ کے ساتھ بات چیت کرنے کا ایک آسان طریقہ فراہم کرتا ہے۔
یادداشت پر بھی بعد میں تفصیل سے بات کی جائے گی۔
ہم نے اب تک جو ایجنٹ بنایا ہے وہ بے وطن ہے، یعنی اسے پچھلی بات چیت یاد نہیں ہے۔ فالو اپ سوالات اور گفتگو کو فعال کرنے کے لیے، ہمیں ایجنٹ میں میموری شامل کرنے کی ضرورت ہے۔ اس میں دو مراحل شامل ہیں:
- چیٹ کی سرگزشت کو ذخیرہ کرنے کے لیے پرامپٹ میں میموری متغیر شامل کریں۔
- بات چیت کے دوران چیٹ کی سرگزشت پر نظر رکھیں۔
آئیے پرامپٹ میں میموری پلیس ہولڈر شامل کرکے شروع کریں:
from langchain.prompts import MessagesPlaceholder MEMORY_KEY = "chat_history"
prompt = ChatPromptTemplate.from_messages( [ ( "system", "You are a very powerful assistant but not great at calculating word lengths.", ), MessagesPlaceholder(variable_name=MEMORY_KEY), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ]
)
اب، چیٹ کی سرگزشت کو ٹریک کرنے کے لیے ایک فہرست بنائیں:
from langchain.schema.messages import HumanMessage, AIMessage chat_history = []
ایجنٹ بنانے کے مرحلے میں، ہم میموری کو بھی شامل کریں گے:
agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_function_messages( x["intermediate_steps"] ), "chat_history": lambda x: x["chat_history"], } | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser()
)
اب، ایجنٹ چلاتے وقت، چیٹ کی سرگزشت کو اپ ڈیٹ کرنا یقینی بنائیں:
input1 = "how many letters in the word educa?"
result = agent_executor.invoke({"input": input1, "chat_history": chat_history})
chat_history.extend([ HumanMessage(content=input1), AIMessage(content=result["output"]),
])
agent_executor.invoke({"input": "is that a real word?", "chat_history": chat_history})
یہ ایجنٹ کو بات چیت کی تاریخ کو برقرار رکھنے اور سابقہ تعاملات کی بنیاد پر فالو اپ سوالات کا جواب دینے کے قابل بناتا ہے۔
مبارک ہو! آپ نے LangChain میں اپنا پہلا اینڈ ٹو اینڈ ایجنٹ کامیابی کے ساتھ بنایا اور اس پر عمل درآمد کر لیا ہے۔ LangChain کی صلاحیتوں کو مزید گہرائی میں جاننے کے لیے، آپ دریافت کر سکتے ہیں:
- مختلف ایجنٹ کی اقسام کی حمایت کی.
- پری بلٹ ایجنٹس
- ٹولز اور ٹول انٹیگریشن کے ساتھ کیسے کام کریں۔
ایجنٹ کی اقسام
LangChain ایجنٹ کی مختلف اقسام پیش کرتا ہے، ہر ایک مخصوص استعمال کے معاملات کے لیے موزوں ہے۔ یہاں دستیاب ایجنٹوں میں سے کچھ ہیں:
- زیرو شاٹ ری ایکٹ: یہ ایجنٹ صرف ان کی تفصیل پر مبنی ٹولز کو منتخب کرنے کے لیے ReAct فریم ورک کا استعمال کرتا ہے۔ اسے ہر ٹول کے لیے وضاحت کی ضرورت ہوتی ہے اور یہ انتہائی ورسٹائل ہے۔
- سٹرکچرڈ ان پٹ ReAct: یہ ایجنٹ ملٹی ان پٹ ٹولز کو ہینڈل کرتا ہے اور ویب براؤزر کو نیویگیٹ کرنے جیسے پیچیدہ کاموں کے لیے موزوں ہے۔ یہ سٹرکچرڈ ان پٹ کے لیے ٹولز کا آرگومنٹ اسکیما استعمال کرتا ہے۔
- OpenAI افعال: خاص طور پر فنکشن کالنگ کے لیے موزوں ماڈلز کے لیے ڈیزائن کیا گیا، یہ ایجنٹ gpt-3.5-turbo-0613 اور gpt-4-0613 جیسے ماڈلز کے ساتھ مطابقت رکھتا ہے۔ ہم نے اسے اوپر اپنا پہلا ایجنٹ بنانے کے لیے استعمال کیا۔
- بات چیت: بات چیت کی ترتیبات کے لیے ڈیزائن کیا گیا، یہ ایجنٹ ٹول سلیکشن کے لیے ReAct کا استعمال کرتا ہے اور پچھلے تعاملات کو یاد رکھنے کے لیے میموری کا استعمال کرتا ہے۔
- تلاش کے ساتھ خود سے پوچھیں: یہ ایجنٹ ایک ٹول پر انحصار کرتا ہے، "انٹرمیڈیٹ جواب،" جو سوالات کے حقائق پر مبنی جوابات تلاش کرتا ہے۔ یہ سرچ پیپر کے ساتھ اصل خود سے پوچھنے کے برابر ہے۔
- ReAct دستاویز کی دکان: یہ ایجنٹ ReAct فریم ورک کا استعمال کرتے ہوئے دستاویز کی دکان کے ساتھ تعامل کرتا ہے۔ اس کے لیے "تلاش" اور "لُک اپ" ٹولز کی ضرورت ہوتی ہے اور یہ اصل ReAct پیپر کی ویکیپیڈیا مثال سے ملتا جلتا ہے۔
LangChain میں آپ کی ضروریات کے لیے موزوں ترین ایجنٹ تلاش کرنے کے لیے ان ایجنٹ کی اقسام کو دریافت کریں۔ یہ ایجنٹ آپ کو کارروائیوں کو سنبھالنے اور ردعمل پیدا کرنے کے لیے اپنے اندر ٹولز کے سیٹ کو باندھنے کی اجازت دیتے ہیں۔ پر مزید جانیں یہاں ٹولز کے ساتھ اپنا ایجنٹ کیسے بنائیں.
پری بلٹ ایجنٹس
آئیے LangChain میں دستیاب پہلے سے تعمیر شدہ ایجنٹوں پر توجہ مرکوز کرتے ہوئے ایجنٹوں کی تلاش جاری رکھیں۔
Gmail کے
LangChain ایک Gmail ٹول کٹ پیش کرتا ہے جو آپ کو اپنے LangChain ای میل کو Gmail API سے جوڑنے کی اجازت دیتا ہے۔ شروع کرنے کے لیے، آپ کو اپنی اسناد ترتیب دینے کی ضرورت ہوگی، جن کی وضاحت Gmail API دستاویزات میں کی گئی ہے۔ ایک بار جب آپ ڈاؤن لوڈ کر لیں۔ credentials.json
فائل، آپ Gmail API کا استعمال کرتے ہوئے آگے بڑھ سکتے ہیں۔ مزید برآں، آپ کو درج ذیل کمانڈز کا استعمال کرتے ہوئے کچھ مطلوبہ لائبریریاں انسٹال کرنے کی ضرورت ہوگی۔
pip install --upgrade google-api-python-client > /dev/null
pip install --upgrade google-auth-oauthlib > /dev/null
pip install --upgrade google-auth-httplib2 > /dev/null
pip install beautifulsoup4 > /dev/null # Optional for parsing HTML messages
آپ Gmail ٹول کٹ کو مندرجہ ذیل بنا سکتے ہیں:
from langchain.agents.agent_toolkits import GmailToolkit toolkit = GmailToolkit()
آپ اپنی ضرورت کے مطابق توثیق بھی کر سکتے ہیں۔ پردے کے پیچھے، مندرجہ ذیل طریقوں کا استعمال کرتے ہوئے ایک googleapi وسیلہ بنایا گیا ہے۔
from langchain.tools.gmail.utils import build_resource_service, get_gmail_credentials credentials = get_gmail_credentials( token_file="token.json", scopes=["https://mail.google.com/"], client_secrets_file="credentials.json",
)
api_resource = build_resource_service(credentials=credentials)
toolkit = GmailToolkit(api_resource=api_resource)
ٹول کٹ مختلف ٹولز پیش کرتی ہے جو ایک ایجنٹ کے اندر استعمال کیے جا سکتے ہیں، بشمول:
GmailCreateDraft
: مخصوص میسج فیلڈز کے ساتھ ایک ڈرافٹ ای میل بنائیں۔GmailSendMessage
: ای میل پیغامات بھیجیں۔GmailSearch
: ای میل پیغامات یا تھریڈز تلاش کریں۔GmailGetMessage
: پیغام کی شناخت کے ذریعے ای میل حاصل کریں۔GmailGetThread
: ای میل پیغامات تلاش کریں۔
ایجنٹ کے اندر ان ٹولز کو استعمال کرنے کے لیے، آپ ایجنٹ کو اس طرح شروع کر سکتے ہیں:
from langchain.llms import OpenAI
from langchain.agents import initialize_agent, AgentType llm = OpenAI(temperature=0)
agent = initialize_agent( tools=toolkit.get_tools(), llm=llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
)
یہاں کچھ مثالیں ہیں کہ ان ٹولز کو کس طرح استعمال کیا جا سکتا ہے:
- ترمیم کے لیے جی میل ڈرافٹ بنائیں:
agent.run( "Create a gmail draft for me to edit of a letter from the perspective of a sentient parrot " "who is looking to collaborate on some research with her estranged friend, a cat. " "Under no circumstances may you send the message, however."
)
- اپنے مسودوں میں تازہ ترین ای میل تلاش کریں:
agent.run("Could you search in my drafts for the latest email?")
یہ مثالیں ایک ایجنٹ کے اندر LangChain کی Gmail ٹول کٹ کی صلاحیتوں کو ظاہر کرتی ہیں، جو آپ کو Gmail کے ساتھ پروگرام کے لحاظ سے بات چیت کرنے کے قابل بناتی ہیں۔
ایس کیو ایل ڈیٹا بیس ایجنٹ
یہ سیکشن ایس کیو ایل ڈیٹا بیس، خاص طور پر چنوک ڈیٹا بیس کے ساتھ تعامل کے لیے ڈیزائن کردہ ایجنٹ کا جائزہ فراہم کرتا ہے۔ یہ ایجنٹ ڈیٹا بیس کے بارے میں عام سوالات کے جوابات دے سکتا ہے اور غلطیوں سے باز آ سکتا ہے۔ براہ کرم نوٹ کریں کہ یہ اب بھی فعال ترقی میں ہے، اور ہو سکتا ہے کہ تمام جوابات درست نہ ہوں۔ اسے حساس ڈیٹا پر چلاتے وقت محتاط رہیں، کیونکہ یہ آپ کے ڈیٹا بیس پر ڈی ایم ایل اسٹیٹمنٹس انجام دے سکتا ہے۔
اس ایجنٹ کو استعمال کرنے کے لیے، آپ اسے اس طرح شروع کر سکتے ہیں:
from langchain.agents import create_sql_agent
from langchain.agents.agent_toolkits import SQLDatabaseToolkit
from langchain.sql_database import SQLDatabase
from langchain.llms.openai import OpenAI
from langchain.agents import AgentExecutor
from langchain.agents.agent_types import AgentType
from langchain.chat_models import ChatOpenAI db = SQLDatabase.from_uri("sqlite:///../../../../../notebooks/Chinook.db")
toolkit = SQLDatabaseToolkit(db=db, llm=OpenAI(temperature=0)) agent_executor = create_sql_agent( llm=OpenAI(temperature=0), toolkit=toolkit, verbose=True, agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
)
اس ایجنٹ کو استعمال کرکے شروع کیا جاسکتا ہے۔ ZERO_SHOT_REACT_DESCRIPTION
ایجنٹ کی قسم یہ سوالات کے جوابات اور وضاحت فراہم کرنے کے لیے ڈیزائن کیا گیا ہے۔ متبادل طور پر، آپ ایجنٹ کو استعمال کر کے شروع کر سکتے ہیں۔ OPENAI_FUNCTIONS
OpenAI کے GPT-3.5-ٹربو ماڈل کے ساتھ ایجنٹ کی قسم، جسے ہم اپنے پہلے کلائنٹ میں استعمال کرتے تھے۔
اعلانِ لاتعلقی
- استفسار کا سلسلہ سوالات داخل/اپ ڈیٹ/ڈیلیٹ کر سکتا ہے۔ محتاط رہیں، اور حسب ضرورت پرامپٹ استعمال کریں یا ضرورت پڑنے پر تحریری اجازت کے بغیر SQL صارف بنائیں۔
- آگاہ رہیں کہ کچھ سوالات کو چلانے سے، جیسے کہ "سب سے بڑا استفسار ممکن ہے چلائیں"، آپ کے SQL ڈیٹا بیس کو اوورلوڈ کر سکتا ہے، خاص طور پر اگر اس میں لاکھوں قطاریں ہوں۔
- ڈیٹا گودام پر مبنی ڈیٹا بیس اکثر وسائل کے استعمال کو محدود کرنے کے لیے صارف کی سطح کے کوٹے کی حمایت کرتے ہیں۔
آپ ایجنٹ سے ٹیبل کی وضاحت کرنے کے لیے کہہ سکتے ہیں، جیسے کہ "پلے لسٹ ٹریک" ٹیبل۔ اسے کیسے کرنا ہے اس کی ایک مثال یہ ہے:
agent_executor.run("Describe the playlisttrack table")
ایجنٹ ٹیبل کے اسکیما اور نمونے کی قطاروں کے بارے میں معلومات فراہم کرے گا۔
اگر آپ غلطی سے کسی ایسی میز کے بارے میں پوچھتے ہیں جو موجود نہیں ہے، تو ایجنٹ بازیافت کر سکتا ہے اور قریب ترین مماثل میز کے بارے میں معلومات فراہم کر سکتا ہے۔ مثال کے طور پر:
agent_executor.run("Describe the playlistsong table")
ایجنٹ قریب ترین میچنگ ٹیبل تلاش کرے گا اور اس کے بارے میں معلومات فراہم کرے گا۔
آپ ایجنٹ سے ڈیٹا بیس پر سوالات چلانے کے لیے بھی کہہ سکتے ہیں۔ مثال کے طور پر:
agent_executor.run("List the total sales per country. Which country's customers spent the most?")
ایجنٹ استفسار پر عمل کرے گا اور نتیجہ فراہم کرے گا، جیسے کہ وہ ملک جہاں سب سے زیادہ کل فروخت ہے۔
ہر پلے لسٹ میں ٹریکس کی کل تعداد حاصل کرنے کے لیے، آپ درج ذیل استفسار استعمال کر سکتے ہیں:
agent_executor.run("Show the total number of tracks in each playlist. The Playlist name should be included in the result.")
ایجنٹ پلے لسٹ کے ناموں کے ساتھ متعلقہ کل ٹریک کی گنتی واپس کرے گا۔
ایسے معاملات میں جہاں ایجنٹ کو غلطیوں کا سامنا کرنا پڑتا ہے، یہ ٹھیک ہو سکتا ہے اور درست جوابات فراہم کر سکتا ہے۔ مثال کے طور پر:
agent_executor.run("Who are the top 3 best selling artists?")
ابتدائی غلطی کا سامنا کرنے کے بعد بھی، ایجنٹ ایڈجسٹ کرے گا اور درست جواب فراہم کرے گا، جو اس معاملے میں سب سے زیادہ فروخت ہونے والے 3 فنکاروں میں سے ہے۔
پانڈاس ڈیٹا فریم ایجنٹ
یہ سیکشن ایک ایجنٹ کو متعارف کراتا ہے جسے سوال جواب دینے کے مقاصد کے لیے پانڈاس ڈیٹا فریمز کے ساتھ بات چیت کرنے کے لیے ڈیزائن کیا گیا ہے۔ براہ کرم نوٹ کریں کہ یہ ایجنٹ لینگویج ماڈل (LLM) کے ذریعے تیار کردہ Python کوڈ کو چلانے کے لیے ہڈ کے نیچے Python ایجنٹ کا استعمال کرتا ہے۔ LLM کے ذریعے تیار کردہ نقصان دہ Python کوڈ سے ممکنہ نقصان کو روکنے کے لیے اس ایجنٹ کا استعمال کرتے وقت احتیاط برتیں۔
آپ پانڈاس ڈیٹا فریم ایجنٹ کو اس طرح شروع کر سکتے ہیں:
from langchain_experimental.agents.agent_toolkits import create_pandas_dataframe_agent
from langchain.chat_models import ChatOpenAI
from langchain.agents.agent_types import AgentType from langchain.llms import OpenAI
import pandas as pd df = pd.read_csv("titanic.csv") # Using ZERO_SHOT_REACT_DESCRIPTION agent type
agent = create_pandas_dataframe_agent(OpenAI(temperature=0), df, verbose=True) # Alternatively, using OPENAI_FUNCTIONS agent type
# agent = create_pandas_dataframe_agent(
# ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613"),
# df,
# verbose=True,
# agent_type=AgentType.OPENAI_FUNCTIONS,
# )
آپ ایجنٹ سے ڈیٹا فریم میں قطاروں کی تعداد گننے کے لیے کہہ سکتے ہیں:
agent.run("how many rows are there?")
ایجنٹ کوڈ پر عمل درآمد کرے گا۔ df.shape[0]
اور جواب فراہم کریں، جیسے کہ "ڈیٹا فریم میں 891 قطاریں ہیں۔"
آپ ایجنٹ سے مخصوص معیار کی بنیاد پر قطاروں کو فلٹر کرنے کے لیے بھی کہہ سکتے ہیں، جیسے کہ 3 سے زیادہ بہن بھائیوں کی تعداد تلاش کرنا:
agent.run("how many people have more than 3 siblings")
ایجنٹ کوڈ پر عمل درآمد کرے گا۔ df[df['SibSp'] > 3].shape[0]
اور جواب فراہم کریں، جیسے کہ "30 لوگوں کے 3 سے زیادہ بہن بھائی ہیں۔"
اگر آپ اوسط عمر کے مربع جڑ کا حساب لگانا چاہتے ہیں، تو آپ ایجنٹ سے پوچھ سکتے ہیں:
agent.run("whats the square root of the average age?")
ایجنٹ استعمال کرتے ہوئے اوسط عمر کا حساب لگائے گا۔ df['Age'].mean()
اور پھر استعمال کرتے ہوئے مربع جڑ کا حساب لگائیں۔ math.sqrt()
. یہ جواب فراہم کرے گا، جیسے کہ "اوسط عمر کا مربع جڑ 5.449689683556195 ہے۔"
آئیے ڈیٹا فریم کی ایک کاپی بنائیں، اور عمر کی گمشدہ اقدار اوسط عمر سے بھری ہوئی ہیں:
df1 = df.copy()
df1["Age"] = df1["Age"].fillna(df1["Age"].mean())
پھر، آپ ایجنٹ کو دونوں ڈیٹا فریمز کے ساتھ شروع کر سکتے ہیں اور اس سے ایک سوال پوچھ سکتے ہیں:
agent = create_pandas_dataframe_agent(OpenAI(temperature=0), [df, df1], verbose=True)
agent.run("how many rows in the age column are different?")
ایجنٹ دونوں ڈیٹا فریمز میں عمر کے کالموں کا موازنہ کرے گا اور جواب فراہم کرے گا، جیسے کہ "عمر کے کالم میں 177 قطاریں مختلف ہیں۔"
جیرا ٹول کٹ
یہ سیکشن بتاتا ہے کہ جیرا ٹول کٹ کو کیسے استعمال کیا جائے، جو ایجنٹوں کو جیرا مثال کے ساتھ بات چیت کرنے کی اجازت دیتا ہے۔ آپ اس ٹول کٹ کا استعمال کرتے ہوئے مختلف کام انجام دے سکتے ہیں جیسے مسائل کی تلاش اور مسائل پیدا کرنا۔ یہ atlassian-python-api لائبریری کا استعمال کرتا ہے۔ اس ٹول کٹ کو استعمال کرنے کے لیے، آپ کو اپنے جیرا مثال کے لیے ماحولیاتی متغیرات سیٹ کرنے ہوں گے، بشمول JIRA_API_TOKEN، JIRA_USERNAME، اور JIRA_INSTANCE_URL۔ مزید برآں، آپ کو اپنی OpenAI API کلید کو ماحولیاتی متغیر کے طور پر سیٹ کرنے کی ضرورت پڑ سکتی ہے۔
شروع کرنے کے لیے، atlassian-python-api لائبریری انسٹال کریں اور مطلوبہ ماحولیاتی متغیرات سیٹ کریں:
%pip install atlassian-python-api import os
from langchain.agents import AgentType
from langchain.agents import initialize_agent
from langchain.agents.agent_toolkits.jira.toolkit import JiraToolkit
from langchain.llms import OpenAI
from langchain.utilities.jira import JiraAPIWrapper os.environ["JIRA_API_TOKEN"] = "abc"
os.environ["JIRA_USERNAME"] = "123"
os.environ["JIRA_INSTANCE_URL"] = "https://jira.atlassian.com"
os.environ["OPENAI_API_KEY"] = "xyz" llm = OpenAI(temperature=0)
jira = JiraAPIWrapper()
toolkit = JiraToolkit.from_jira_api_wrapper(jira)
agent = initialize_agent( toolkit.get_tools(), llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
آپ ایجنٹ کو کسی مخصوص پروجیکٹ میں خلاصہ اور تفصیل کے ساتھ نیا مسئلہ بنانے کی ہدایت کر سکتے ہیں:
agent.run("make a new issue in project PW to remind me to make more fried rice")
ایجنٹ ایشو بنانے اور جواب دینے کے لیے ضروری کارروائیاں کرے گا، جیسے کہ "پروجیکٹ PW میں خلاصہ 'مزید تلے ہوئے چاول بنائیں' اور 'مزید تلے ہوئے چاول بنانے کی یاد دہانی' کے ساتھ ایک نیا مسئلہ تخلیق کیا گیا ہے۔"
یہ آپ کو قدرتی زبان کی ہدایات اور جیرا ٹول کٹ کا استعمال کرتے ہوئے اپنے جیرا مثال کے ساتھ بات چیت کرنے کی اجازت دیتا ہے۔
ہمارے AI سے چلنے والے ورک فلو بلڈر کے ساتھ دستی کاموں اور ورک فلو کو خودکار بنائیں، جسے Nanonets نے آپ اور آپ کی ٹیموں کے لیے ڈیزائن کیا ہے۔
ماڈیول IV : زنجیریں
LangChain پیچیدہ ایپلی کیشنز میں بڑے لینگویج ماڈلز (LLMs) کو استعمال کرنے کے لیے ڈیزائن کیا گیا ایک ٹول ہے۔ یہ اجزاء کی زنجیریں بنانے کے لیے فریم ورک فراہم کرتا ہے، بشمول LLMs اور اجزاء کی دیگر اقسام۔ دو بنیادی فریم ورک
- لینگ چین ایکسپریشن لینگویج (LCEL)
- میراثی سلسلہ انٹرفیس
LangChain Expression Language (LCEL) ایک نحو ہے جو زنجیروں کی بدیہی ساخت کی اجازت دیتا ہے۔ یہ اسٹریمنگ، غیر مطابقت پذیر کالز، بیچنگ، متوازی، دوبارہ کوششیں، فال بیکس، اور ٹریسنگ جیسی جدید خصوصیات کو سپورٹ کرتا ہے۔ مثال کے طور پر، آپ LCEL میں ایک پرامپٹ، ماڈل، اور آؤٹ پٹ پارسر لکھ سکتے ہیں جیسا کہ درج ذیل کوڈ میں دکھایا گیا ہے۔
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
prompt = ChatPromptTemplate.from_messages([ ("system", "You're a very knowledgeable historian who provides accurate and eloquent answers to historical questions."), ("human", "{question}")
])
runnable = prompt | model | StrOutputParser() for chunk in runnable.stream({"question": "What are the seven wonders of the world"}): print(chunk, end="", flush=True)
متبادل طور پر، LLMCchain اجزاء کی کمپوزنگ کے لیے LCEL کی طرح ایک آپشن ہے۔ LLMChain مثال درج ذیل ہے:
from langchain.chains import LLMChain chain = LLMChain(llm=model, prompt=prompt, output_parser=StrOutputParser())
chain.run(question="What are the seven wonders of the world")
LangChain میں زنجیریں بھی میموری آبجیکٹ کو شامل کرکے اسٹیٹفول ہوسکتی ہیں۔ یہ کالوں میں ڈیٹا کو برقرار رکھنے کی اجازت دیتا ہے، جیسا کہ اس مثال میں دکھایا گیا ہے:
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory conversation = ConversationChain(llm=chat, memory=ConversationBufferMemory())
conversation.run("Answer briefly. What are the first 3 colors of a rainbow?")
conversation.run("And the next 4?")
LangChain OpenAI کے فنکشن کالنگ APIs کے ساتھ انضمام کی بھی حمایت کرتا ہے، جو سٹرکچرڈ آؤٹ پٹ حاصل کرنے اور ایک سلسلہ کے اندر افعال کو انجام دینے کے لیے مفید ہے۔ سٹرکچرڈ آؤٹ پٹ حاصل کرنے کے لیے، آپ Pydantic کلاسز یا JsonSchema کا استعمال کرتے ہوئے ان کی وضاحت کر سکتے ہیں، جیسا کہ ذیل میں دکھایا گیا ہے:
from langchain.pydantic_v1 import BaseModel, Field
from langchain.chains.openai_functions import create_structured_output_runnable
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate class Person(BaseModel): name: str = Field(..., description="The person's name") age: int = Field(..., description="The person's age") fav_food: Optional[str] = Field(None, description="The person's favorite food") llm = ChatOpenAI(model="gpt-4", temperature=0)
prompt = ChatPromptTemplate.from_messages([ # Prompt messages here
]) runnable = create_structured_output_runnable(Person, llm, prompt)
runnable.invoke({"input": "Sally is 13"})
سٹرکچرڈ آؤٹ پٹس کے لیے، LLMCchain کا استعمال کرتے ہوئے میراثی طریقہ بھی دستیاب ہے:
from langchain.chains.openai_functions import create_structured_output_chain class Person(BaseModel): name: str = Field(..., description="The person's name") age: int = Field(..., description="The person's age") chain = create_structured_output_chain(Person, llm, prompt, verbose=True)
chain.run("Sally is 13")
LangChain مختلف مقاصد کے لیے مختلف مخصوص زنجیریں بنانے کے لیے OpenAI افعال کا فائدہ اٹھاتا ہے۔ ان میں اقتباسات کے ساتھ نکالنے، ٹیگنگ، OpenAPI، اور QA کی زنجیریں شامل ہیں۔
نکالنے کے تناظر میں، یہ عمل ساختی آؤٹ پٹ چین کی طرح ہے لیکن معلومات یا ہستی نکالنے پر توجہ مرکوز کرتا ہے۔ ٹیگنگ کے لیے، خیال یہ ہے کہ کسی دستاویز کو کلاسز کے ساتھ لیبل کیا جائے جیسے جذبات، زبان، انداز، احاطہ کیے گئے موضوعات، یا سیاسی رجحان۔
LangChain میں ٹیگنگ کیسے کام کرتی ہے اس کی ایک مثال Python کوڈ سے ظاہر کی جا سکتی ہے۔ یہ عمل ضروری پیکجوں کو انسٹال کرنے اور ماحول کو ترتیب دینے کے ساتھ شروع ہوتا ہے:
pip install langchain openai
# Set env var OPENAI_API_KEY or load from a .env file:
# import dotenv
# dotenv.load_dotenv() from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import create_tagging_chain, create_tagging_chain_pydantic
ٹیگنگ کے لیے اسکیما کی وضاحت کی گئی ہے، خصوصیات اور ان کی متوقع اقسام کی وضاحت کرتے ہوئے:
schema = { "properties": { "sentiment": {"type": "string"}, "aggressiveness": {"type": "integer"}, "language": {"type": "string"}, }
} llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613")
chain = create_tagging_chain(schema, llm)
ٹیگنگ چین کو مختلف ان پٹ کے ساتھ چلانے کی مثالیں ماڈل کی جذبات، زبانوں اور جارحیت کی ترجمانی کرنے کی صلاحیت کو ظاہر کرتی ہیں:
inp = "Estoy increiblemente contento de haberte conocido! Creo que seremos muy buenos amigos!"
chain.run(inp)
# {'sentiment': 'positive', 'language': 'Spanish'} inp = "Estoy muy enojado con vos! Te voy a dar tu merecido!"
chain.run(inp)
# {'sentiment': 'enojado', 'aggressiveness': 1, 'language': 'es'}
بہتر کنٹرول کے لیے، اسکیما کو زیادہ خاص طور پر بیان کیا جا سکتا ہے، بشمول ممکنہ اقدار، وضاحتیں، اور مطلوبہ خصوصیات۔ اس بہتر کنٹرول کی ایک مثال ذیل میں دکھائی گئی ہے۔
schema = { "properties": { # Schema definitions here }, "required": ["language", "sentiment", "aggressiveness"],
} chain = create_tagging_chain(schema, llm)
Pydantic اسکیموں کو ٹیگنگ کے معیار کی وضاحت کے لیے بھی استعمال کیا جا سکتا ہے، مطلوبہ خصوصیات اور اقسام کی وضاحت کرنے کے لیے Pythonic طریقہ فراہم کرتے ہوئے:
from enum import Enum
from pydantic import BaseModel, Field class Tags(BaseModel): # Class fields here chain = create_tagging_chain_pydantic(Tags, llm)
مزید برآں، LangChain کے میٹا ڈیٹا ٹیگر دستاویز ٹرانسفارمر کو LangChain دستاویزات سے میٹا ڈیٹا نکالنے کے لیے استعمال کیا جا سکتا ہے، جو ٹیگنگ چین کے لیے اسی طرح کی فعالیت پیش کرتا ہے لیکن LangChain دستاویز پر لاگو ہوتا ہے۔
بازیافت کے ذرائع کا حوالہ دینا LangChain کی ایک اور خصوصیت ہے، متن سے اقتباسات نکالنے کے لیے OpenAI فنکشنز کا استعمال۔ یہ مندرجہ ذیل کوڈ میں ظاہر ہوتا ہے:
from langchain.chains import create_citation_fuzzy_match_chain
from langchain.chat_models import ChatOpenAI llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613")
chain = create_citation_fuzzy_match_chain(llm)
# Further code for running the chain and displaying results
LangChain میں، Large Language Model (LLM) ایپلی کیشنز میں سلسلہ بندی میں عام طور پر ایک پرامپٹ ٹیمپلیٹ کو LLM اور اختیاری طور پر آؤٹ پٹ پارسر کے ساتھ ملانا شامل ہوتا ہے۔ ایسا کرنے کا تجویز کردہ طریقہ LangChain Expression Language (LCEL) کے ذریعے ہے، حالانکہ میراثی LLMCchain اپروچ بھی معاون ہے۔
LCEL کا استعمال کرتے ہوئے، BasePromptTemplate، BaseLanguageModel، اور BaseOutputParser سبھی رن ایبل انٹرفیس کو نافذ کرتے ہیں اور آسانی سے ایک دوسرے میں پائپ کیا جا سکتا ہے۔ یہاں اس کا مظاہرہ کرنے والی ایک مثال ہے:
from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.schema import StrOutputParser prompt = PromptTemplate.from_template( "What is a good name for a company that makes {product}?"
)
runnable = prompt | ChatOpenAI() | StrOutputParser()
runnable.invoke({"product": "colorful socks"})
# Output: 'VibrantSocks'
LangChain میں روٹنگ نان ڈیٹرمنسٹک چینز بنانے کی اجازت دیتی ہے جہاں پچھلے مرحلے کی آؤٹ پٹ اگلے مرحلے کا تعین کرتی ہے۔ یہ LLMs کے ساتھ تعاملات کی ساخت اور مستقل مزاجی کو برقرار رکھنے میں مدد کرتا ہے۔ مثال کے طور پر، اگر آپ کے پاس مختلف قسم کے سوالات کے لیے آپٹمائزڈ دو ٹیمپلیٹس ہیں، تو آپ صارف کے ان پٹ کی بنیاد پر ٹیمپلیٹ کا انتخاب کر سکتے ہیں۔
یہ ہے کہ آپ RunnableBranch کے ساتھ LCEL کا استعمال کرتے ہوئے اسے کیسے حاصل کر سکتے ہیں، جس کی شروعات (حالت، چلنے کے قابل) جوڑوں کی فہرست اور پہلے سے طے شدہ چلانے کے قابل ہے۔
from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableBranch
# Code for defining physics_prompt and math_prompt general_prompt = PromptTemplate.from_template( "You are a helpful assistant. Answer the question as accurately as you can.nn{input}"
)
prompt_branch = RunnableBranch( (lambda x: x["topic"] == "math", math_prompt), (lambda x: x["topic"] == "physics", physics_prompt), general_prompt,
) # More code for setting up the classifier and final chain
اس کے بعد حتمی سلسلہ مختلف اجزاء کا استعمال کرتے ہوئے بنایا جاتا ہے، جیسے کہ موضوع کی درجہ بندی کرنے والا، پرامپٹ برانچ، اور آؤٹ پٹ پارسر، ان پٹ کے موضوع کی بنیاد پر بہاؤ کا تعین کرنے کے لیے:
from operator import itemgetter
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough final_chain = ( RunnablePassthrough.assign(topic=itemgetter("input") | classifier_chain) | prompt_branch | ChatOpenAI() | StrOutputParser()
) final_chain.invoke( { "input": "What is the first prime number greater than 40 such that one plus the prime number is divisible by 3?" }
)
# Output: Detailed answer to the math question
یہ نقطہ نظر پیچیدہ سوالات سے نمٹنے اور ان پٹ کی بنیاد پر مناسب طریقے سے روٹ کرنے میں LangChain کی لچک اور طاقت کی مثال دیتا ہے۔
لینگوئج ماڈلز کے دائرے میں، ایک عام پریکٹس یہ ہے کہ ایک کال کے آؤٹ پٹ کو اگلی کال کے ان پٹ کے طور پر استعمال کرتے ہوئے، بعد میں آنے والی کالوں کی ایک سیریز کے ساتھ ایک ابتدائی کال کی پیروی کی جائے۔ یہ ترتیب وار نقطہ نظر خاص طور پر فائدہ مند ہے جب آپ سابقہ تعاملات میں پیدا ہونے والی معلومات پر استوار کرنا چاہتے ہیں۔ اگرچہ LangChain Expression Language (LCEL) ان ترتیبوں کو بنانے کے لیے تجویز کردہ طریقہ ہے، لیکن SequentialChain طریقہ اب بھی اس کی پسماندہ مطابقت کے لیے دستاویزی ہے۔
اس کی وضاحت کے لیے، آئیے ایک ایسے منظر نامے پر غور کریں جہاں ہم پہلے ڈرامے کا خلاصہ تیار کرتے ہیں اور پھر اس خلاصے کی بنیاد پر ایک جائزہ لیتے ہیں۔ Python کا استعمال کرنا langchain.prompts
، ہم دو بناتے ہیں۔ PromptTemplate
مثالیں: ایک خلاصہ کے لیے اور دوسرا جائزہ کے لیے۔ ان ٹیمپلیٹس کو ترتیب دینے کا کوڈ یہ ہے:
from langchain.prompts import PromptTemplate synopsis_prompt = PromptTemplate.from_template( "You are a playwright. Given the title of play, it is your job to write a synopsis for that title.nnTitle: {title}nPlaywright: This is a synopsis for the above play:"
) review_prompt = PromptTemplate.from_template( "You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.nnPlay Synopsis:n{synopsis}nReview from a New York Times play critic of the above play:"
)
LCEL کے نقطہ نظر میں، ہم ان اشارے کے ساتھ زنجیر بناتے ہیں۔ ChatOpenAI
اور StrOutputParser
ایک ترتیب بنانے کے لیے جو پہلے ایک خلاصہ اور پھر ایک جائزہ تیار کرے۔ کوڈ کا ٹکڑا درج ذیل ہے:
from langchain.chat_models import ChatOpenAI
from langchain.schema import StrOutputParser llm = ChatOpenAI()
chain = ( {"synopsis": synopsis_prompt | llm | StrOutputParser()} | review_prompt | llm | StrOutputParser()
)
chain.invoke({"title": "Tragedy at sunset on the beach"})
اگر ہمیں خلاصہ اور جائزہ دونوں کی ضرورت ہو تو ہم استعمال کر سکتے ہیں۔ RunnablePassthrough
ہر ایک کے لیے الگ سلسلہ بنانے کے لیے اور پھر ان کو یکجا کرنا:
from langchain.schema.runnable import RunnablePassthrough synopsis_chain = synopsis_prompt | llm | StrOutputParser()
review_chain = review_prompt | llm | StrOutputParser()
chain = {"synopsis": synopsis_chain} | RunnablePassthrough.assign(review=review_chain)
chain.invoke({"title": "Tragedy at sunset on the beach"})
زیادہ پیچیدہ ترتیبوں پر مشتمل منظرناموں کے لیے، SequentialChain
طریقہ کار میں آتا ہے. یہ متعدد ان پٹ اور آؤٹ پٹ کی اجازت دیتا ہے۔ اس معاملے پر غور کریں جہاں ہمیں ڈرامے کے عنوان اور دور کی بنیاد پر ایک خلاصہ کی ضرورت ہے۔ یہاں ہے کہ ہم اسے کیسے ترتیب دے سکتے ہیں:
from langchain.llms import OpenAI
from langchain.chains import LLMChain, SequentialChain
from langchain.prompts import PromptTemplate llm = OpenAI(temperature=0.7) synopsis_template = "You are a playwright. Given the title of play and the era it is set in, it is your job to write a synopsis for that title.nnTitle: {title}nEra: {era}nPlaywright: This is a synopsis for the above play:"
synopsis_prompt_template = PromptTemplate(input_variables=["title", "era"], template=synopsis_template)
synopsis_chain = LLMChain(llm=llm, prompt=synopsis_prompt_template, output_key="synopsis") review_template = "You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.nnPlay Synopsis:n{synopsis}nReview from a New York Times play critic of the above play:"
prompt_template = PromptTemplate(input_variables=["synopsis"], template=review_template)
review_chain = LLMChain(llm=llm, prompt=prompt_template, output_key="review") overall_chain = SequentialChain( chains=[synopsis_chain, review_chain], input_variables=["era", "title"], output_variables=["synopsis", "review"], verbose=True,
) overall_chain({"title": "Tragedy at sunset on the beach", "era": "Victorian England"})
ایسے منظرناموں میں جہاں آپ پورے سلسلہ میں یا سلسلہ کے بعد کے حصے کے لیے سیاق و سباق کو برقرار رکھنا چاہتے ہیں، SimpleMemory
استعمال کیا جا سکتا ہے. یہ خاص طور پر پیچیدہ ان پٹ/آؤٹ پٹ تعلقات کے انتظام کے لیے مفید ہے۔ مثال کے طور پر، ایک ایسے منظر نامے میں جہاں ہم ڈرامے کے عنوان، زمانے، خلاصہ اور جائزے کی بنیاد پر سوشل میڈیا پوسٹس بنانا چاہتے ہیں، SimpleMemory
ان متغیرات کو منظم کرنے میں مدد کر سکتے ہیں:
from langchain.memory import SimpleMemory
from langchain.chains import SequentialChain template = "You are a social media manager for a theater company. Given the title of play, the era it is set in, the date, time and location, the synopsis of the play, and the review of the play, it is your job to write a social media post for that play.nnHere is some context about the time and location of the play:nDate and Time: {time}nLocation: {location}nnPlay Synopsis:n{synopsis}nReview from a New York Times play critic of the above play:n{review}nnSocial Media Post:"
prompt_template = PromptTemplate(input_variables=["synopsis", "review", "time", "location"], template=template)
social_chain = LLMChain(llm=llm, prompt=prompt_template, output_key="social_post_text") overall_chain = SequentialChain( memory=SimpleMemory(memories={"time": "December 25th, 8pm PST", "location": "Theater in the Park"}), chains=[synopsis_chain, review_chain, social_chain], input_variables=["era", "title"], output_variables=["social_post_text"], verbose=True,
) overall_chain({"title": "Tragedy at sunset on the beach", "era": "Victorian England"})
ترتیب وار زنجیروں کے علاوہ، دستاویزات کے ساتھ کام کرنے کے لیے خصوصی زنجیریں ہیں۔ ان زنجیروں میں سے ہر ایک مختلف مقصد کی تکمیل کرتا ہے، دستاویزات کو یکجا کرنے سے لے کر تکراری دستاویز کے تجزیے کی بنیاد پر جوابات کو بہتر بنانے، نقشہ سازی اور دستاویز کے مواد کو خلاصہ کرنے یا اسکور کیے گئے جوابات کی بنیاد پر دوبارہ درجہ بندی کرنے تک۔ اضافی لچک اور حسب ضرورت کے لیے ان زنجیروں کو LCEL کے ساتھ دوبارہ بنایا جا سکتا ہے۔
-
StuffDocumentsChain
LLM کو بھیجے گئے ایک ہی پرامپٹ میں دستاویزات کی فہرست کو یکجا کرتا ہے۔ -
RefineDocumentsChain
ہر دستاویز کے لیے اس کے جواب کو بار بار اپ ڈیٹ کرتا ہے، ان کاموں کے لیے موزوں ہے جہاں دستاویزات ماڈل کی سیاق و سباق کی گنجائش سے زیادہ ہوں۔ -
MapReduceDocumentsChain
ہر دستاویز پر انفرادی طور پر ایک سلسلہ لاگو کرتا ہے اور پھر نتائج کو یکجا کرتا ہے۔ -
MapRerankDocumentsChain
ہر دستاویز پر مبنی جواب کو اسکور کرتا ہے اور سب سے زیادہ اسکور کرنے والے کو منتخب کرتا ہے۔
یہاں ایک مثال ہے کہ آپ کیسے سیٹ اپ کرسکتے ہیں۔ MapReduceDocumentsChain
LCEL کا استعمال کرتے ہوئے:
from functools import partial
from langchain.chains.combine_documents import collapse_docs, split_list_of_docs
from langchain.schema import Document, StrOutputParser
from langchain.schema.prompt_template import format_document
from langchain.schema.runnable import RunnableParallel, RunnablePassthrough llm = ChatAnthropic()
document_prompt = PromptTemplate.from_template("{page_content}")
partial_format_document = partial(format_document, prompt=document_prompt) map_chain = ( {"context": partial_format_document} | PromptTemplate.from_template("Summarize this content:nn{context}") | llm | StrOutputParser()
) map_as_doc_chain = ( RunnableParallel({"doc": RunnablePassthrough(), "content": map_chain}) | (lambda x: Document(page_content=x["content"], metadata=x["doc"].metadata))
).with_config(run_name="Summarize (return doc)") def format_docs(docs): return "nn".join(partial_format_document(doc) for doc in docs) collapse_chain = ( {"context": format_docs} | PromptTemplate.from_template("Collapse this content:nn{context}") | llm | StrOutputParser()
) reduce_chain = ( {"context": format_docs} | PromptTemplate.from_template("Combine these summaries:nn{context}") | llm | StrOutputParser()
).with_config(run_name="Reduce") map_reduce = (map_as_doc_chain.map() | collapse | reduce_chain).with_config(run_name="Map reduce")
یہ کنفیگریشن LCEL کی طاقت اور بنیادی زبان کے ماڈل کا فائدہ اٹھاتے ہوئے دستاویز کے مواد کے تفصیلی اور جامع تجزیہ کی اجازت دیتی ہے۔
ہمارے AI سے چلنے والے ورک فلو بلڈر کے ساتھ دستی کاموں اور ورک فلو کو خودکار بنائیں، جسے Nanonets نے آپ اور آپ کی ٹیموں کے لیے ڈیزائن کیا ہے۔
ماڈیول V: میموری
LangChain میں، میموری بات چیت کے انٹرفیس کا ایک بنیادی پہلو ہے، جو سسٹمز کو ماضی کے تعاملات کا حوالہ دینے کی اجازت دیتا ہے۔ یہ معلومات کو ذخیرہ کرنے اور استفسار کرنے کے ذریعے حاصل کیا جاتا ہے، دو بنیادی اعمال کے ساتھ: پڑھنا اور لکھنا۔ میموری سسٹم ایک رن کے دوران ایک زنجیر کے ساتھ دو بار تعامل کرتا ہے، صارف کے ان پٹ کو بڑھاتا ہے اور مستقبل کے حوالے کے لیے ان پٹس اور آؤٹ پٹس کو اسٹور کرتا ہے۔
سسٹم میں میموری کی تعمیر
- چیٹ پیغامات کو ذخیرہ کرنا: LangChain میموری ماڈیول چیٹ پیغامات کو ذخیرہ کرنے کے لیے مختلف طریقوں کو مربوط کرتا ہے، جس میں میموری کی فہرستوں سے لے کر ڈیٹا بیس تک شامل ہیں۔ یہ یقینی بناتا ہے کہ تمام چیٹ تعاملات مستقبل کے حوالے کے لیے ریکارڈ کیے گئے ہیں۔
- چیٹ پیغامات سے استفسار کرنا: چیٹ پیغامات کو ذخیرہ کرنے کے علاوہ، LangChain ان پیغامات کا ایک مفید منظر تخلیق کرنے کے لیے ڈیٹا ڈھانچے اور الگورتھم کو ملازمت دیتا ہے۔ سادہ میموری سسٹمز حالیہ پیغامات واپس کر سکتے ہیں، جبکہ زیادہ جدید نظام ماضی کے تعاملات کا خلاصہ کر سکتے ہیں یا موجودہ تعامل میں مذکور اداروں پر توجہ مرکوز کر سکتے ہیں۔
LangChain میں میموری کے استعمال کو ظاہر کرنے کے لیے، غور کریں۔ ConversationBufferMemory
کلاس، ایک سادہ میموری فارم جو چیٹ پیغامات کو بفر میں اسٹور کرتا ہے۔ یہاں ایک مثال ہے:
from langchain.memory import ConversationBufferMemory memory = ConversationBufferMemory()
memory.chat_memory.add_user_message("Hello!")
memory.chat_memory.add_ai_message("How can I assist you?")
میموری کو زنجیر میں ضم کرتے وقت، یہ سمجھنا بہت ضروری ہے کہ میموری سے واپس آنے والے متغیرات اور انہیں چین میں کیسے استعمال کیا جاتا ہے۔ مثال کے طور پر، load_memory_variables
طریقہ یادداشت سے پڑھے گئے متغیرات کو سلسلہ کی توقعات کے ساتھ سیدھ میں کرنے میں مدد کرتا ہے۔
LangChain کے ساتھ اینڈ ٹو اینڈ مثال
استعمال کرنے پر غور کریں ConversationBufferMemory
ایک میں LLMChain
. یہ سلسلہ، ایک مناسب پرامپٹ ٹیمپلیٹ اور میموری کے ساتھ مل کر، ایک ہموار گفتگو کا تجربہ فراہم کرتا ہے۔ یہاں ایک آسان مثال ہے:
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory llm = OpenAI(temperature=0)
template = "Your conversation template here..."
prompt = PromptTemplate.from_template(template)
memory = ConversationBufferMemory(memory_key="chat_history")
conversation = LLMChain(llm=llm, prompt=prompt, memory=memory) response = conversation({"question": "What's the weather like?"})
یہ مثال واضح کرتی ہے کہ کس طرح لینگ چین کا میموری سسٹم اپنی زنجیروں کے ساتھ مربوط اور سیاق و سباق سے آگاہ گفتگو کا تجربہ فراہم کرتا ہے۔
لینگچین میں میموری کی اقسام
Langchain میموری کی مختلف اقسام پیش کرتا ہے جنہیں AI ماڈلز کے ساتھ تعامل کو بڑھانے کے لیے استعمال کیا جا سکتا ہے۔ میموری کی ہر قسم کے اپنے پیرامیٹرز اور واپسی کی قسمیں ہوتی ہیں، جو انہیں مختلف منظرناموں کے لیے موزوں بناتی ہیں۔ آئیے کوڈ کی مثالوں کے ساتھ لینگچین میں دستیاب میموری کی کچھ اقسام کو دریافت کریں۔
1. گفتگو کی بفر میموری
میموری کی یہ قسم آپ کو بات چیت سے پیغامات کو ذخیرہ کرنے اور نکالنے کی اجازت دیتی ہے۔ آپ تاریخ کو بطور تار یا پیغامات کی فہرست کے طور پر نکال سکتے ہیں۔
from langchain.memory import ConversationBufferMemory memory = ConversationBufferMemory()
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.load_memory_variables({}) # Extract history as a string
{'history': 'Human: hinAI: whats up'} # Extract history as a list of messages
{'history': [HumanMessage(content='hi', additional_kwargs={}), AIMessage(content='whats up', additional_kwargs={})]}
آپ بات چیت کی طرح کی بات چیت کے لیے ایک سلسلہ میں گفتگو کی بفر میموری بھی استعمال کر سکتے ہیں۔
2. گفتگو بفر ونڈو میموری
میموری کی یہ قسم حالیہ تعاملات کی فہرست رکھتی ہے اور آخری K تعاملات کا استعمال کرتی ہے، بفر کو بہت زیادہ ہونے سے روکتی ہے۔
from langchain.memory import ConversationBufferWindowMemory memory = ConversationBufferWindowMemory(k=1)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})
memory.load_memory_variables({}) {'history': 'Human: not much younAI: not much'}
بات چیت کی بفر میموری کی طرح، آپ اس میموری کی قسم کو بھی چیٹ جیسے تعاملات کے لیے ایک سلسلہ میں استعمال کر سکتے ہیں۔
3. گفتگو کی ہستی کی یادداشت
میموری کی یہ قسم گفتگو میں مخصوص اداروں کے بارے میں حقائق کو یاد رکھتی ہے اور LLM کا استعمال کرتے ہوئے معلومات نکالتی ہے۔
from langchain.memory import ConversationEntityMemory
from langchain.llms import OpenAI llm = OpenAI(temperature=0)
memory = ConversationEntityMemory(llm=llm)
_input = {"input": "Deven & Sam are working on a hackathon project"}
memory.load_memory_variables(_input)
memory.save_context( _input, {"output": " That sounds like a great project! What kind of project are they working on?"}
)
memory.load_memory_variables({"input": 'who is Sam'}) {'history': 'Human: Deven & Sam are working on a hackathon projectnAI: That sounds like a great project! What kind of project are they working on?', 'entities': {'Sam': 'Sam is working on a hackathon project with Deven.'}}
4. گفتگو کے علم کا گراف میموری
میموری کی یہ قسم میموری کو دوبارہ بنانے کے لیے علمی گراف کا استعمال کرتی ہے۔ آپ پیغامات سے موجودہ ہستیوں اور علم کے ٹرپلٹس کو نکال سکتے ہیں۔
from langchain.memory import ConversationKGMemory
from langchain.llms import OpenAI llm = OpenAI(temperature=0)
memory = ConversationKGMemory(llm=llm)
memory.save_context({"input": "say hi to sam"}, {"output": "who is sam"})
memory.save_context({"input": "sam is a friend"}, {"output": "okay"})
memory.load_memory_variables({"input": "who is sam"}) {'history': 'On Sam: Sam is friend.'}
آپ اس میموری کی قسم کو گفتگو پر مبنی علم کی بازیافت کے لیے ایک سلسلہ میں بھی استعمال کر سکتے ہیں۔
5. گفتگو کا خلاصہ میموری
میموری کی یہ قسم وقت کے ساتھ ساتھ گفتگو کا خلاصہ بناتی ہے، جو طویل گفتگو سے معلومات کو کم کرنے کے لیے مفید ہے۔
from langchain.memory import ConversationSummaryMemory
from langchain.llms import OpenAI llm = OpenAI(temperature=0)
memory = ConversationSummaryMemory(llm=llm)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.load_memory_variables({}) {'history': 'nThe human greets the AI, to which the AI responds.'}
6. گفتگو کا خلاصہ بفر میموری
یہ میموری کی قسم گفتگو کے خلاصے اور بفر کو یکجا کرتی ہے، حالیہ تعاملات اور خلاصے کے درمیان توازن برقرار رکھتی ہے۔ یہ تعاملات کو فلش کرنے کا تعین کرنے کے لیے ٹوکن کی لمبائی کا استعمال کرتا ہے۔
from langchain.memory import ConversationSummaryBufferMemory
from langchain.llms import OpenAI llm = OpenAI()
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=10)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})
memory.load_memory_variables({}) {'history': 'System: nThe human says "hi", and the AI responds with "whats up".nHuman: not much younAI: not much'}
آپ ان میموری کی اقسام کو Langchain میں AI ماڈلز کے ساتھ اپنے تعامل کو بڑھانے کے لیے استعمال کر سکتے ہیں۔ میموری کی ہر قسم ایک خاص مقصد کی تکمیل کرتی ہے اور آپ کی ضروریات کی بنیاد پر منتخب کیا جا سکتا ہے۔
7. گفتگو کا ٹوکن بفر میموری
ConversationTokenBufferMemory میموری کی ایک اور قسم ہے جو میموری میں حالیہ تعاملات کا بفر رکھتی ہے۔ پچھلی میموری کی اقسام کے برعکس جو تعاملات کی تعداد پر توجہ مرکوز کرتی ہے، یہ ایک ٹوکن کی لمبائی کا استعمال کرتا ہے تاکہ تعاملات کو کب فلش کیا جائے۔
ایل ایل ایم کے ساتھ میموری کا استعمال:
from langchain.memory import ConversationTokenBufferMemory
from langchain.llms import OpenAI llm = OpenAI() memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=10)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"}) memory.load_memory_variables({}) {'history': 'Human: not much younAI: not much'}
اس مثال میں، میموری تعاملات کی تعداد کے بجائے ٹوکن کی لمبائی کی بنیاد پر تعاملات کو محدود کرنے کے لیے سیٹ کی گئی ہے۔
اس میموری کی قسم کو استعمال کرتے وقت آپ تاریخ کو پیغامات کی فہرست کے طور پر بھی حاصل کر سکتے ہیں۔
memory = ConversationTokenBufferMemory( llm=llm, max_token_limit=10, return_messages=True
)
memory.save_context({"input": "hi"}, {"output": "whats up"})
memory.save_context({"input": "not much you"}, {"output": "not much"})
زنجیر میں استعمال کرنا:
آپ AI ماڈل کے ساتھ تعاملات کو بڑھانے کے لیے ConversationTokenBufferMemory کو ایک سلسلہ میں استعمال کر سکتے ہیں۔
from langchain.chains import ConversationChain conversation_with_summary = ConversationChain( llm=llm, # We set a very low max_token_limit for the purposes of testing. memory=ConversationTokenBufferMemory(llm=OpenAI(), max_token_limit=60), verbose=True,
)
conversation_with_summary.predict(input="Hi, what's up?")
اس مثال میں، ConversationTokenBufferMemory کو گفتگو کا نظم کرنے اور ٹوکن کی لمبائی کی بنیاد پر تعاملات کو محدود کرنے کے لیے ConversationChain میں استعمال کیا جاتا ہے۔
8. VectorStoreRetrieverMemory
VectorStoreRetrieverMemory ایک ویکٹر اسٹور میں یادوں کو اسٹور کرتی ہے اور جب بھی کال کی جاتی ہے تو ٹاپ-K کے سب سے زیادہ "نمایاں" دستاویزات سے استفسار کرتی ہے۔ میموری کی یہ قسم واضح طور پر تعاملات کی ترتیب کو ٹریک نہیں کرتی ہے لیکن متعلقہ یادوں کو حاصل کرنے کے لیے ویکٹر کی بازیافت کا استعمال کرتی ہے۔
from datetime import datetime
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.memory import VectorStoreRetrieverMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate # Initialize your vector store (specifics depend on the chosen vector store)
import faiss
from langchain.docstore import InMemoryDocstore
from langchain.vectorstores import FAISS embedding_size = 1536 # Dimensions of the OpenAIEmbeddings
index = faiss.IndexFlatL2(embedding_size)
embedding_fn = OpenAIEmbeddings().embed_query
vectorstore = FAISS(embedding_fn, index, InMemoryDocstore({}), {}) # Create your VectorStoreRetrieverMemory
retriever = vectorstore.as_retriever(search_kwargs=dict(k=1))
memory = VectorStoreRetrieverMemory(retriever=retriever) # Save context and relevant information to the memory
memory.save_context({"input": "My favorite food is pizza"}, {"output": "that's good to know"})
memory.save_context({"input": "My favorite sport is soccer"}, {"output": "..."})
memory.save_context({"input": "I don't like the Celtics"}, {"output": "ok"}) # Retrieve relevant information from memory based on a query
print(memory.load_memory_variables({"prompt": "what sport should i watch?"})["history"])
اس مثال میں، VectorStoreRetrieverMemory کا استعمال ویکٹر کی بازیافت پر مبنی گفتگو سے متعلقہ معلومات کو ذخیرہ کرنے اور بازیافت کرنے کے لیے کیا جاتا ہے۔
آپ VectorStoreRetrieverMemory کو گفتگو پر مبنی علم کی بازیافت کے لیے ایک سلسلہ میں بھی استعمال کر سکتے ہیں، جیسا کہ پچھلی مثالوں میں دکھایا گیا ہے۔
Langchain میں میموری کی یہ مختلف اقسام گفتگو سے معلومات کو منظم اور بازیافت کرنے کے مختلف طریقے فراہم کرتی ہیں، صارف کے سوالات اور سیاق و سباق کو سمجھنے اور ان کا جواب دینے میں AI ماڈلز کی صلاحیتوں کو بڑھاتی ہیں۔ ہر میموری کی قسم کو آپ کی درخواست کی مخصوص ضروریات کی بنیاد پر منتخب کیا جا سکتا ہے۔
اب ہم LLMCchain کے ساتھ میموری کو استعمال کرنے کا طریقہ سیکھیں گے۔ LLMCchain میں میموری ماڈل کو پچھلے تعاملات اور سیاق و سباق کو یاد رکھنے کی اجازت دیتی ہے تاکہ زیادہ مربوط اور سیاق و سباق سے آگاہ جوابات فراہم کیے جاسکیں۔
LLMCchain میں میموری سیٹ اپ کرنے کے لیے، آپ کو ایک میموری کلاس بنانے کی ضرورت ہے، جیسا کہ ConversationBufferMemory۔ یہاں یہ ہے کہ آپ اسے کیسے ترتیب دے سکتے ہیں:
from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory
from langchain.prompts import PromptTemplate template = """You are a chatbot having a conversation with a human. {chat_history}
Human: {human_input}
Chatbot:""" prompt = PromptTemplate( input_variables=["chat_history", "human_input"], template=template
)
memory = ConversationBufferMemory(memory_key="chat_history") llm = OpenAI()
llm_chain = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory,
) llm_chain.predict(human_input="Hi there my friend")
اس مثال میں، ConversationBufferMemory کو گفتگو کی تاریخ کو ذخیرہ کرنے کے لیے استعمال کیا جاتا ہے۔ دی memory_key
پیرامیٹر بات چیت کی تاریخ کو ذخیرہ کرنے کے لیے استعمال ہونے والی کلید کی وضاحت کرتا ہے۔
اگر آپ تکمیلی طرز کے ماڈل کے بجائے چیٹ ماڈل استعمال کر رہے ہیں، تو آپ میموری کو بہتر طریقے سے استعمال کرنے کے لیے اپنے اشارے کو مختلف طریقے سے تشکیل دے سکتے ہیں۔ یہاں ایک مثال ہے کہ میموری کے ساتھ چیٹ ماڈل پر مبنی LLMCchain کیسے ترتیب دیا جائے:
from langchain.chat_models import ChatOpenAI
from langchain.schema import SystemMessage
from langchain.prompts import ( ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder,
) # Create a ChatPromptTemplate
prompt = ChatPromptTemplate.from_messages( [ SystemMessage( content="You are a chatbot having a conversation with a human." ), # The persistent system prompt MessagesPlaceholder( variable_name="chat_history" ), # Where the memory will be stored. HumanMessagePromptTemplate.from_template( "{human_input}" ), # Where the human input will be injected ]
) memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True) llm = ChatOpenAI() chat_llm_chain = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory,
) chat_llm_chain.predict(human_input="Hi there my friend")
اس مثال میں، ChatPromptTemplate کو پرامپٹ کی ساخت کے لیے استعمال کیا جاتا ہے، اور ConversationBufferMemory کو گفتگو کی تاریخ کو ذخیرہ کرنے اور بازیافت کرنے کے لیے استعمال کیا جاتا ہے۔ یہ نقطہ نظر چیٹ طرز کی گفتگو کے لیے خاص طور پر مفید ہے جہاں سیاق و سباق اور تاریخ ایک اہم کردار ادا کرتی ہے۔
میموری کو ایک سے زیادہ ان پٹ کے ساتھ ایک سلسلہ میں بھی شامل کیا جا سکتا ہے، جیسے کہ سوال/جواب دینے کا سلسلہ۔ سوال/جواب دینے والے سلسلہ میں میموری کو کیسے ترتیب دیا جائے اس کی ایک مثال یہ ہے:
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.embeddings.cohere import CohereEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores.elastic_vector_search import ElasticVectorSearch
from langchain.vectorstores import Chroma
from langchain.docstore.document import Document
from langchain.chains.question_answering import load_qa_chain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.memory import ConversationBufferMemory # Split a long document into smaller chunks
with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_text(state_of_the_union) # Create an ElasticVectorSearch instance to index and search the document chunks
embeddings = OpenAIEmbeddings()
docsearch = Chroma.from_texts( texts, embeddings, metadatas=[{"source": i} for i in range(len(texts))]
) # Perform a question about the document
query = "What did the president say about Justice Breyer"
docs = docsearch.similarity_search(query) # Set up a prompt for the question-answering chain with memory
template = """You are a chatbot having a conversation with a human. Given the following extracted parts of a long document and a question, create a final answer. {context} {chat_history}
Human: {human_input}
Chatbot:""" prompt = PromptTemplate( input_variables=["chat_history", "human_input", "context"], template=template
)
memory = ConversationBufferMemory(memory_key="chat_history", input_key="human_input")
chain = load_qa_chain( OpenAI(temperature=0), chain_type="stuff", memory=memory, prompt=prompt
) # Ask the question and retrieve the answer
query = "What did the president say about Justice Breyer"
result = chain({"input_documents": docs, "human_input": query}, return_only_outputs=True) print(result)
print(chain.memory.buffer)
اس مثال میں، ایک سوال کا جواب ایک دستاویز کا استعمال کرتے ہوئے چھوٹے حصوں میں تقسیم کیا جاتا ہے۔ ConversationBufferMemory کا استعمال گفتگو کی تاریخ کو ذخیرہ کرنے اور بازیافت کرنے کے لیے کیا جاتا ہے، جس سے ماڈل کو سیاق و سباق سے آگاہ جوابات فراہم کرنے کی اجازت ملتی ہے۔
کسی ایجنٹ میں میموری کو شامل کرنے سے اسے سوالات کا جواب دینے اور سیاق و سباق سے آگاہ جوابات فراہم کرنے کے لیے پچھلی بات چیت کو یاد رکھنے اور استعمال کرنے کی اجازت ملتی ہے۔ یہاں ہے کہ آپ ایجنٹ میں میموری کیسے ترتیب دے سکتے ہیں:
from langchain.agents import ZeroShotAgent, Tool, AgentExecutor
from langchain.memory import ConversationBufferMemory
from langchain.llms import OpenAI
from langchain.chains import LLMChain
from langchain.utilities import GoogleSearchAPIWrapper # Create a tool for searching
search = GoogleSearchAPIWrapper()
tools = [ Tool( name="Search", func=search.run, description="useful for when you need to answer questions about current events", )
] # Create a prompt with memory
prefix = """Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:"""
suffix = """Begin!" {chat_history}
Question: {input}
{agent_scratchpad}""" prompt = ZeroShotAgent.create_prompt( tools, prefix=prefix, suffix=suffix, input_variables=["input", "chat_history", "agent_scratchpad"],
)
memory = ConversationBufferMemory(memory_key="chat_history") # Create an LLMChain with memory
llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)
agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)
agent_chain = AgentExecutor.from_agent_and_tools( agent=agent, tools=tools, verbose=True, memory=memory
) # Ask a question and retrieve the answer
response = agent_chain.run(input="How many people live in Canada?")
print(response) # Ask a follow-up question
response = agent_chain.run(input="What is their national anthem called?")
print(response)
اس مثال میں، میموری کو ایجنٹ میں شامل کیا جاتا ہے، جس سے وہ پچھلی گفتگو کی تاریخ کو یاد رکھ سکتا ہے اور سیاق و سباق سے آگاہ جوابات فراہم کرتا ہے۔ یہ ایجنٹ کو اس قابل بناتا ہے کہ وہ میموری میں محفوظ معلومات کی بنیاد پر فالو اپ سوالات کا درست جواب دے سکے۔
LangChain اظہار کی زبان
قدرتی زبان کی پروسیسنگ اور مشین لرننگ کی دنیا میں، آپریشنز کی پیچیدہ زنجیروں کی تشکیل ایک مشکل کام ہو سکتا ہے۔ خوش قسمتی سے، LangChain Expression Language (LCEL) بچاؤ کے لیے آتا ہے، جو جدید ترین لینگویج پروسیسنگ پائپ لائنوں کی تعمیر اور تعیناتی کا اعلانیہ اور موثر طریقہ فراہم کرتا ہے۔ LCEL کو کمپوزنگ چینز کے عمل کو آسان بنانے کے لیے ڈیزائن کیا گیا ہے، جس سے پروٹو ٹائپنگ سے پروڈکشن تک آسانی سے جانا ممکن ہو جاتا ہے۔ اس بلاگ میں، ہم دریافت کریں گے کہ LCEL کیا ہے اور آپ اسے کیوں استعمال کرنا چاہیں گے، اس کی صلاحیتوں کو واضح کرنے کے لیے عملی کوڈ کی مثالوں کے ساتھ۔
ایل سی ای ایل، یا لینگ چین ایکسپریشن لینگویج، لینگویج پروسیسنگ چینز کو کمپوز کرنے کا ایک طاقتور ٹول ہے۔ کوڈ میں وسیع تبدیلیوں کی ضرورت کے بغیر، بغیر کسی رکاوٹ کے پروٹو ٹائپنگ سے پروڈکشن میں منتقلی کی حمایت کرنے کے لیے اسے مقصد سے بنایا گیا تھا۔ چاہے آپ ایک سادہ "پرامپٹ + LLM" چین بنا رہے ہوں یا سینکڑوں قدموں والی ایک پیچیدہ پائپ لائن، LCEL نے آپ کا احاطہ کیا ہے۔
آپ کے لینگویج پروسیسنگ پروجیکٹس میں LCEL استعمال کرنے کی کچھ وجوہات یہ ہیں:
- تیز ٹوکن سٹریمنگ: ایل سی ای ایل ایک لینگویج ماڈل سے ریئل ٹائم میں آؤٹ پٹ پارسر کو ٹوکن فراہم کرتا ہے، جس سے ردعمل اور کارکردگی میں بہتری آتی ہے۔
- ورسٹائل APIs: LCEL پروٹو ٹائپنگ اور پروڈکشن کے استعمال کے لیے ہم وقت ساز اور غیر مطابقت پذیر APIs دونوں کو سپورٹ کرتا ہے، متعدد درخواستوں کو مؤثر طریقے سے ہینڈل کرتا ہے۔
- خودکار ہم آہنگی: LCEL جب ممکن ہو متوازی عمل کو بہتر بناتا ہے، مطابقت پذیری اور async دونوں انٹرفیس میں تاخیر کو کم کرتا ہے۔
- قابل اعتماد کنفیگریشنز: ڈیولپمنٹ میں اسٹریمنگ سپورٹ کے ساتھ پیمانہ پر بہتر چین کی وشوسنییتا کے لیے دوبارہ کوششوں اور فال بیکس کو ترتیب دیں۔
- اسٹریم انٹرمیڈیٹ کے نتائج: صارف کے اپ ڈیٹس یا ڈیبگنگ کے مقاصد کے لیے پروسیسنگ کے دوران انٹرمیڈیٹ نتائج تک رسائی حاصل کریں۔
- اسکیما جنریشن: LCEL ان پٹ اور آؤٹ پٹ کی توثیق کے لیے Pydantic اور JSONSchema اسکیما تیار کرتا ہے۔
- جامع ٹریسنگ: لینگ اسمتھ مشاہدے اور ڈیبگنگ کے لیے پیچیدہ زنجیروں میں خود بخود تمام مراحل کا سراغ لگاتا ہے۔
- آسان تعیناتی: LangServe کا استعمال کرتے ہوئے LCEL کی تخلیق کردہ زنجیروں کو آسانی سے تعینات کریں۔
اب، آئیے عملی کوڈ کی مثالوں میں غوطہ لگائیں جو LCEL کی طاقت کو ظاہر کرتی ہیں۔ ہم عام کاموں اور منظرناموں کو تلاش کریں گے جہاں LCEL چمکتا ہے۔
پرامپٹ + ایل ایل ایم
سب سے بنیادی کمپوزیشن میں پرامپٹ اور لینگویج ماڈل کو ملا کر ایک سلسلہ بنانا شامل ہے جو صارف کا ان پٹ لیتا ہے، اسے پرامپٹ میں شامل کرتا ہے، اسے ماڈل تک پہنچاتا ہے، اور خام ماڈل آؤٹ پٹ واپس کرتا ہے۔ یہاں ایک مثال ہے:
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI prompt = ChatPromptTemplate.from_template("tell me a joke about {foo}")
model = ChatOpenAI()
chain = prompt | model result = chain.invoke({"foo": "bears"})
print(result)
اس مثال میں، سلسلہ ریچھ کے بارے میں ایک لطیفہ پیدا کرتا ہے۔
آپ اپنی زنجیر کے ساتھ سٹاپ کی ترتیب منسلک کر سکتے ہیں تاکہ یہ کنٹرول کیا جا سکے کہ یہ متن پر کیسے عمل کرتا ہے۔ مثال کے طور پر:
chain = prompt | model.bind(stop=["n"])
result = chain.invoke({"foo": "bears"})
print(result)
یہ کنفیگریشن ٹیکسٹ جنریشن کو روک دیتی ہے جب ایک نئی لائن کریکٹر کا سامنا ہوتا ہے۔
LCEL آپ کی چین میں فنکشن کال کی معلومات کو منسلک کرنے کی حمایت کرتا ہے۔ یہاں ایک مثال ہے:
functions = [ { "name": "joke", "description": "A joke", "parameters": { "type": "object", "properties": { "setup": {"type": "string", "description": "The setup for the joke"}, "punchline": { "type": "string", "description": "The punchline for the joke", }, }, "required": ["setup", "punchline"], }, }
]
chain = prompt | model.bind(function_call={"name": "joke"}, functions=functions)
result = chain.invoke({"foo": "bears"}, config={})
print(result)
یہ مثال مذاق پیدا کرنے کے لیے فنکشن کال کی معلومات کو منسلک کرتی ہے۔
پرامپٹ + ایل ایل ایم + آؤٹ پٹ پارسر
آپ خام ماڈل کے آؤٹ پٹ کو زیادہ قابل عمل شکل میں تبدیل کرنے کے لیے آؤٹ پٹ پارسر شامل کر سکتے ہیں۔ یہاں یہ ہے کہ آپ اسے کیسے کر سکتے ہیں:
from langchain.schema.output_parser import StrOutputParser chain = prompt | model | StrOutputParser()
result = chain.invoke({"foo": "bears"})
print(result)
آؤٹ پٹ اب ایک سٹرنگ فارمیٹ میں ہے، جو نیچے کی دھارے کے کاموں کے لیے زیادہ آسان ہے۔
واپسی کے لیے کسی فنکشن کی وضاحت کرتے وقت، آپ LCEL کا استعمال کرتے ہوئے اسے براہ راست پارس کر سکتے ہیں۔ مثال کے طور پر:
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser chain = ( prompt | model.bind(function_call={"name": "joke"}, functions=functions) | JsonOutputFunctionsParser()
)
result = chain.invoke({"foo": "bears"})
print(result)
یہ مثال "مذاق" فنکشن کے آؤٹ پٹ کو براہ راست پارس کرتی ہے۔
یہ صرف چند مثالیں ہیں کہ کس طرح LCEL پیچیدہ لینگویج پروسیسنگ کے کاموں کو آسان بناتا ہے۔ چاہے آپ چیٹ بوٹس بنا رہے ہوں، مواد تیار کر رہے ہوں، یا متن کی پیچیدہ تبدیلیاں کر رہے ہوں، LCEL آپ کے ورک فلو کو ہموار کر سکتا ہے اور آپ کے کوڈ کو مزید قابلِ انتظام بنا سکتا ہے۔
RAG (بازیافت میں اضافہ شدہ جنریشن)
LCEL کا استعمال بازیافت کے لیے بڑھا ہوا جنریشن چینز بنانے کے لیے کیا جا سکتا ہے، جو کہ بازیافت اور زبان کی تخلیق کے مراحل کو یکجا کرتی ہے۔ یہاں ایک مثال ہے:
from operator import itemgetter from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough, RunnableLambda
from langchain.vectorstores import FAISS # Create a vector store and retriever
vectorstore = FAISS.from_texts( ["harrison worked at kensho"], embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever() # Define templates for prompts
template = """Answer the question based only on the following context:
{context} Question: {question} """
prompt = ChatPromptTemplate.from_template(template) model = ChatOpenAI() # Create a retrieval-augmented generation chain
chain = ( {"context": retriever, "question": RunnablePassthrough()} | prompt | model | StrOutputParser()
) result = chain.invoke("where did harrison work?")
print(result)
اس مثال میں، سلسلہ سیاق و سباق سے متعلقہ معلومات کو بازیافت کرتا ہے اور سوال کا جواب تیار کرتا ہے۔
بات چیت کی بازیافت کا سلسلہ
آپ آسانی سے اپنی زنجیروں میں گفتگو کی سرگزشت شامل کر سکتے ہیں۔ بات چیت کی بازیافت کے سلسلے کی ایک مثال یہ ہے:
from langchain.schema.runnable import RunnableMap
from langchain.schema import format_document from langchain.prompts.prompt import PromptTemplate # Define templates for prompts
_template = """Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question, in its original language. Chat History:
{chat_history}
Follow Up Input: {question}
Standalone question:"""
CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template) template = """Answer the question based only on the following context:
{context} Question: {question} """
ANSWER_PROMPT = ChatPromptTemplate.from_template(template) # Define input map and context
_inputs = RunnableMap( standalone_question=RunnablePassthrough.assign( chat_history=lambda x: _format_chat_history(x["chat_history"]) ) | CONDENSE_QUESTION_PROMPT | ChatOpenAI(temperature=0) | StrOutputParser(),
)
_context = { "context": itemgetter("standalone_question") | retriever | _combine_documents, "question": lambda x: x["standalone_question"],
}
conversational_qa_chain = _inputs | _context | ANSWER_PROMPT | ChatOpenAI() result = conversational_qa_chain.invoke( { "question": "where did harrison work?", "chat_history": [], }
)
print(result)
اس مثال میں، سلسلہ گفتگو کے تناظر میں ایک فالو اپ سوال کو ہینڈل کرتا ہے۔
میموری اور ریٹرننگ ماخذ دستاویزات کے ساتھ
LCEL میموری اور واپسی ماخذ دستاویزات کو بھی سپورٹ کرتا ہے۔ یہاں یہ ہے کہ آپ ایک سلسلہ میں میموری کو کس طرح استعمال کرسکتے ہیں:
from operator import itemgetter
from langchain.memory import ConversationBufferMemory # Create a memory instance
memory = ConversationBufferMemory( return_messages=True, output_key="answer", input_key="question"
) # Define steps for the chain
loaded_memory = RunnablePassthrough.assign( chat_history=RunnableLambda(memory.load_memory_variables) | itemgetter("history"),
) standalone_question = { "standalone_question": { "question": lambda x: x["question"], "chat_history": lambda x: _format_chat_history(x["chat_history"]), } | CONDENSE_QUESTION_PROMPT | ChatOpenAI(temperature=0) | StrOutputParser(),
} retrieved_documents = { "docs": itemgetter("standalone_question") | retriever, "question": lambda x: x["standalone_question"],
} final_inputs = { "context": lambda x: _combine_documents(x["docs"]), "question": itemgetter("question"),
} answer = { "answer": final_inputs | ANSWER_PROMPT | ChatOpenAI(), "docs": itemgetter("docs"),
} # Create the final chain by combining the steps
final_chain = loaded_memory | standalone_question | retrieved_documents | answer inputs = {"question": "where did harrison work?"}
result = final_chain.invoke(inputs)
print(result)
اس مثال میں، میموری کا استعمال گفتگو کی تاریخ اور ماخذ دستاویزات کو ذخیرہ کرنے اور بازیافت کرنے کے لیے کیا جاتا ہے۔
متعدد زنجیریں۔
آپ Runnables کا استعمال کرتے ہوئے متعدد زنجیروں کو اکٹھا کر سکتے ہیں۔ یہاں ایک مثال ہے:
from operator import itemgetter from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser prompt1 = ChatPromptTemplate.from_template("what is the city {person} is from?")
prompt2 = ChatPromptTemplate.from_template( "what country is the city {city} in? respond in {language}"
) model = ChatOpenAI() chain1 = prompt1 | model | StrOutputParser() chain2 = ( {"city": chain1, "language": itemgetter("language")} | prompt2 | model | StrOutputParser()
) result = chain2.invoke({"person": "obama", "language": "spanish"})
print(result)
اس مثال میں، ایک مخصوص زبان میں شہر اور اس کے ملک کے بارے میں معلومات پیدا کرنے کے لیے دو زنجیروں کو ملایا جاتا ہے۔
برانچنگ اور ضم کرنا
LCEL آپ کو RunnableMaps کا استعمال کرتے ہوئے زنجیروں کو تقسیم اور ضم کرنے کی اجازت دیتا ہے۔ برانچنگ اور انضمام کی ایک مثال یہ ہے:
from operator import itemgetter from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser planner = ( ChatPromptTemplate.from_template("Generate an argument about: {input}") | ChatOpenAI() | StrOutputParser() | {"base_response": RunnablePassthrough()}
) arguments_for = ( ChatPromptTemplate.from_template( "List the pros or positive aspects of {base_response}" ) | ChatOpenAI() | StrOutputParser()
)
arguments_against = ( ChatPromptTemplate.from_template( "List the cons or negative aspects of {base_response}" ) | ChatOpenAI() | StrOutputParser()
) final_responder = ( ChatPromptTemplate.from_messages( [ ("ai", "{original_response}"), ("human", "Pros:n{results_1}nnCons:n{results_2}"), ("system", "Generate a final response given the critique"), ] ) | ChatOpenAI() | StrOutputParser()
) chain = ( planner | { "results_1": arguments_for, "results_2": arguments_against, "original_response": itemgetter("base_response"), } | final_responder
) result = chain.invoke({"input": "scrum"})
print(result)
اس مثال میں، ایک برانچنگ اور ضم کرنے والی زنجیر کا استعمال دلیل پیدا کرنے اور حتمی ردعمل پیدا کرنے سے پہلے اس کے فوائد اور نقصانات کا جائزہ لینے کے لیے کیا جاتا ہے۔
LCEL کے ساتھ ازگر کوڈ لکھنا
LangChain Expression Language (LCEL) کی طاقتور ایپلی کیشنز میں سے ایک صارف کے مسائل کو حل کرنے کے لیے Python کوڈ لکھ رہی ہے۔ ذیل میں ایک مثال دی گئی ہے کہ Python کوڈ لکھنے کے لیے LCEL کا استعمال کیسے کریں:
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain_experimental.utilities import PythonREPL template = """Write some python code to solve the user's problem. Return only python code in Markdown format, e.g.: ```python
....
```"""
prompt = ChatPromptTemplate.from_messages([("system", template), ("human", "{input}")]) model = ChatOpenAI() def _sanitize_output(text: str): _, after = text.split("```python") return after.split("```")[0] chain = prompt | model | StrOutputParser() | _sanitize_output | PythonREPL().run result = chain.invoke({"input": "what's 2 plus 2"})
print(result)
اس مثال میں، ایک صارف ان پٹ فراہم کرتا ہے، اور LCEL مسئلے کو حل کرنے کے لیے ازگر کوڈ تیار کرتا ہے۔ اس کے بعد کوڈ کو Python REPL کا استعمال کرتے ہوئے عمل میں لایا جاتا ہے، اور نتیجے میں Python کوڈ کو Markdown فارمیٹ میں واپس کر دیا جاتا ہے۔
براہ کرم نوٹ کریں کہ Python REPL کا استعمال صوابدیدی کوڈ پر عمل درآمد کر سکتا ہے، لہذا اسے احتیاط کے ساتھ استعمال کریں۔
ایک سلسلہ میں میموری کو شامل کرنا
بہت سی بات چیت کی AI ایپلی کیشنز میں میموری ضروری ہے۔ صوابدیدی سلسلہ میں میموری کو شامل کرنے کا طریقہ یہاں ہے:
from operator import itemgetter
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.schema.runnable import RunnablePassthrough, RunnableLambda
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder model = ChatOpenAI()
prompt = ChatPromptTemplate.from_messages( [ ("system", "You are a helpful chatbot"), MessagesPlaceholder(variable_name="history"), ("human", "{input}"), ]
) memory = ConversationBufferMemory(return_messages=True) # Initialize memory
memory.load_memory_variables({}) chain = ( RunnablePassthrough.assign( history=RunnableLambda(memory.load_memory_variables) | itemgetter("history") ) | prompt | model
) inputs = {"input": "hi, I'm Bob"}
response = chain.invoke(inputs)
response # Save the conversation in memory
memory.save_context(inputs, {"output": response.content}) # Load memory to see the conversation history
memory.load_memory_variables({})
اس مثال میں، میموری کا استعمال گفتگو کی تاریخ کو ذخیرہ کرنے اور بازیافت کرنے کے لیے کیا جاتا ہے، جس سے چیٹ بوٹ کو سیاق و سباق کو برقرار رکھنے اور مناسب جواب دینے کی اجازت ملتی ہے۔
رن ایبلز کے ساتھ بیرونی ٹولز کا استعمال
LCEL آپ کو بغیر کسی رکاوٹ کے بیرونی ٹولز کو Runnables کے ساتھ مربوط کرنے کی اجازت دیتا ہے۔ DuckDuckGo سرچ ٹول کا استعمال کرتے ہوئے ایک مثال یہ ہے:
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.tools import DuckDuckGoSearchRun search = DuckDuckGoSearchRun() template = """Turn the following user input into a search query for a search engine: {input}"""
prompt = ChatPromptTemplate.from_template(template) model = ChatOpenAI() chain = prompt | model | StrOutputParser() | search search_result = chain.invoke({"input": "I'd like to figure out what games are tonight"})
print(search_result)
اس مثال میں، LCEL DuckDuckGo تلاش کے آلے کو زنجیر میں ضم کرتا ہے، جس سے یہ صارف کے ان پٹ سے تلاش کا سوال پیدا کرنے اور تلاش کے نتائج کو بازیافت کرنے کی اجازت دیتا ہے۔
LCEL کی لچک آپ کی لینگویج پروسیسنگ پائپ لائنز میں مختلف بیرونی ٹولز اور خدمات کو شامل کرنا آسان بناتی ہے، ان کی صلاحیتوں اور فعالیت کو بڑھاتی ہے۔
LLM درخواست میں اعتدال کا اضافہ کرنا
اس بات کو یقینی بنانے کے لیے کہ آپ کی LLM درخواست مواد کی پالیسیوں پر عمل پیرا ہے اور اس میں اعتدال پسندی کے تحفظات شامل ہیں، آپ اعتدال کی جانچ کو اپنے سلسلہ میں ضم کر سکتے ہیں۔ LangChain کا استعمال کرتے ہوئے اعتدال کو شامل کرنے کا طریقہ یہاں ہے:
from langchain.chains import OpenAIModerationChain
from langchain.llms import OpenAI
from langchain.prompts import ChatPromptTemplate moderate = OpenAIModerationChain() model = OpenAI()
prompt = ChatPromptTemplate.from_messages([("system", "repeat after me: {input}")]) chain = prompt | model # Original response without moderation
response_without_moderation = chain.invoke({"input": "you are stupid"})
print(response_without_moderation) moderated_chain = chain | moderate # Response after moderation
response_after_moderation = moderated_chain.invoke({"input": "you are stupid"})
print(response_after_moderation)
اس مثال میں ، OpenAIModerationChain
LLM کے ذریعے پیدا ہونے والے ردعمل میں اعتدال شامل کرنے کے لیے استعمال کیا جاتا ہے۔ اعتدال کا سلسلہ ایسے مواد کے جواب کو چیک کرتا ہے جو OpenAI کی مواد کی پالیسی کی خلاف ورزی کرتا ہے۔ اگر کوئی خلاف ورزی پائی جاتی ہے، تو یہ اس کے مطابق ردعمل کو جھنڈا لگائے گا۔
سیمنٹک مماثلت کے ذریعہ روٹنگ
LCEL آپ کو صارف کے ان پٹ کی معنوی مماثلت کی بنیاد پر حسب ضرورت روٹنگ منطق کو نافذ کرنے کی اجازت دیتا ہے۔ یہاں ایک مثال ہے کہ صارف کے ان پٹ کی بنیاد پر چین کی منطق کو متحرک طور پر کیسے طے کیا جائے:
from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.prompts import PromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableLambda, RunnablePassthrough
from langchain.utils.math import cosine_similarity physics_template = """You are a very smart physics professor. You are great at answering questions about physics in a concise and easy to understand manner. When you don't know the answer to a question you admit that you don't know. Here is a question:
{query}""" math_template = """You are a very good mathematician. You are great at answering math questions. You are so good because you are able to break down hard problems into their component parts, answer the component parts, and then put them together to answer the broader question. Here is a question:
{query}""" embeddings = OpenAIEmbeddings()
prompt_templates = [physics_template, math_template]
prompt_embeddings = embeddings.embed_documents(prompt_templates) def prompt_router(input): query_embedding = embeddings.embed_query(input["query"]) similarity = cosine_similarity([query_embedding], prompt_embeddings)[0] most_similar = prompt_templates[similarity.argmax()] print("Using MATH" if most_similar == math_template else "Using PHYSICS") return PromptTemplate.from_template(most_similar) chain = ( {"query": RunnablePassthrough()} | RunnableLambda(prompt_router) | ChatOpenAI() | StrOutputParser()
) print(chain.invoke({"query": "What's a black hole"}))
print(chain.invoke({"query": "What's a path integral"}))
اس مثال میں ، prompt_router
فنکشن صارف کے ان پٹ اور طبیعیات اور ریاضی کے سوالات کے لیے پہلے سے طے شدہ پرامپٹ ٹیمپلیٹس کے درمیان کوزائن مماثلت کا حساب لگاتا ہے۔ مماثلت کے اسکور کی بنیاد پر، سلسلہ متحرک طور پر سب سے زیادہ متعلقہ پرامپٹ ٹیمپلیٹ کا انتخاب کرتا ہے، اس بات کو یقینی بناتے ہوئے کہ چیٹ بوٹ صارف کے سوال کا مناسب جواب دیتا ہے۔
ایجنٹوں اور رن ایبلز کا استعمال
LangChain آپ کو رن ایبلز، پرامپٹس، ماڈلز اور ٹولز کو ملا کر ایجنٹ بنانے کی اجازت دیتا ہے۔ یہاں ایک ایجنٹ بنانے اور اسے استعمال کرنے کی ایک مثال ہے:
from langchain.agents import XMLAgent, tool, AgentExecutor
from langchain.chat_models import ChatAnthropic model = ChatAnthropic(model="claude-2") @tool
def search(query: str) -> str: """Search things about current events.""" return "32 degrees" tool_list = [search] # Get prompt to use
prompt = XMLAgent.get_default_prompt() # Logic for going from intermediate steps to a string to pass into the model
def convert_intermediate_steps(intermediate_steps): log = "" for action, observation in intermediate_steps: log += ( f"<tool>{action.tool}</tool><tool_input>{action.tool_input}" f"</tool_input><observation>{observation}</observation>" ) return log # Logic for converting tools to a string to go in the prompt
def convert_tools(tools): return "n".join([f"{tool.name}: {tool.description}" for tool in tools]) agent = ( { "question": lambda x: x["question"], "intermediate_steps": lambda x: convert_intermediate_steps( x["intermediate_steps"] ), } | prompt.partial(tools=convert_tools(tool_list)) | model.bind(stop=["</tool_input>", "</final_answer>"]) | XMLAgent.get_default_output_parser()
) agent_executor = AgentExecutor(agent=agent, tools=tool_list, verbose=True) result = agent_executor.invoke({"question": "What's the weather in New York?"})
print(result)
اس مثال میں، ایک ایجنٹ ایک ماڈل، ٹولز، ایک پرامپٹ، اور درمیانی مراحل اور ٹول کی تبدیلی کے لیے ایک حسب ضرورت منطق کو ملا کر بنایا جاتا ہے۔ اس کے بعد ایجنٹ کو پھانسی دی جاتی ہے، صارف کے سوال کا جواب فراہم کرتا ہے۔
ایس کیو ایل ڈیٹا بیس سے استفسار کرنا
آپ SQL ڈیٹا بیس سے استفسار کرنے اور صارف کے سوالات کی بنیاد پر SQL سوالات تیار کرنے کے لیے LangChain کا استعمال کر سکتے ہیں۔ یہاں ایک مثال ہے:
from langchain.prompts import ChatPromptTemplate template = """Based on the table schema below, write a SQL query that would answer the user's question:
{schema} Question: {question}
SQL Query:"""
prompt = ChatPromptTemplate.from_template(template) from langchain.utilities import SQLDatabase # Initialize the database (you'll need the Chinook sample DB for this example)
db = SQLDatabase.from_uri("sqlite:///./Chinook.db") def get_schema(_): return db.get_table_info() def run_query(query): return db.run(query) from langchain.chat_models import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough model = ChatOpenAI() sql_response = ( RunnablePassthrough.assign(schema=get_schema) | prompt | model.bind(stop=["nSQLResult:"]) | StrOutputParser()
) result = sql_response.invoke({"question": "How many employees are there?"})
print(result) template = """Based on the table schema below, question, SQL query, and SQL response, write a natural language response:
{schema} Question: {question}
SQL Query: {query}
SQL Response: {response}"""
prompt_response = ChatPromptTemplate.from_template(template) full_chain = ( RunnablePassthrough.assign(query=sql_response) | RunnablePassthrough.assign( schema=get_schema, response=lambda x: db.run(x["query"]), ) | prompt_response | model
) response = full_chain.invoke({"question": "How many employees are there?"})
print(response)
اس مثال میں، LangChain کو صارف کے سوالات کی بنیاد پر SQL سوالات پیدا کرنے اور SQL ڈیٹا بیس سے جوابات حاصل کرنے کے لیے استعمال کیا جاتا ہے۔ ڈیٹا بیس کے ساتھ قدرتی زبان کے تعاملات فراہم کرنے کے لیے اشارے اور جوابات فارمیٹ کیے گئے ہیں۔
ہمارے AI سے چلنے والے ورک فلو بلڈر کے ساتھ دستی کاموں اور ورک فلو کو خودکار بنائیں، جسے Nanonets نے آپ اور آپ کی ٹیموں کے لیے ڈیزائن کیا ہے۔
لینگ سرو اور لینگ سمتھ
LangServe ڈیولپرز کو LangChain رن ایبلز اور چینز کو REST API کے طور پر تعینات کرنے میں مدد کرتا ہے۔ یہ لائبریری FastAPI کے ساتھ مربوط ہے اور ڈیٹا کی توثیق کے لیے pydantic کا استعمال کرتی ہے۔ مزید برآں، یہ ایک ایسا کلائنٹ فراہم کرتا ہے جسے سرور پر تعینات رن ایبلز میں کال کرنے کے لیے استعمال کیا جا سکتا ہے، اور ایک JavaScript کلائنٹ LangChainJS میں دستیاب ہے۔
خصوصیات
- ان پٹ اور آؤٹ پٹ اسکیموں کا خود بخود آپ کے LangChain آبجیکٹ سے اندازہ لگایا جاتا ہے اور ہر API کال پر بھرپور غلطی والے پیغامات کے ساتھ نافذ کیا جاتا ہے۔
- JSONSchema اور Swagger کے ساتھ API دستاویزات کا صفحہ دستیاب ہے۔
- ایک ہی سرور پر متعدد سمورتی درخواستوں کے لیے معاونت کے ساتھ موثر /دعوت، /بیچ، اور /اسٹریم اینڈ پوائنٹس۔
- آپ کے چین/ایجنٹ سے تمام (یا کچھ) درمیانی مراحل کو اسٹریم کرنے کے لیے /stream_log اینڈ پوائنٹ۔
- اسٹریمنگ آؤٹ پٹ اور درمیانی مراحل کے ساتھ /playground پر پلے گراؤنڈ کا صفحہ۔
- بلٹ ان (اختیاری) لینگ اسمتھ کو ٹریس کرنا؛ بس اپنی API کلید شامل کریں (ہدایات دیکھیں)۔
- تمام جنگی آزمائشی اوپن سورس Python لائبریریوں جیسے FastAPI، Pydantic، uvloop، اور asyncio کے ساتھ بنایا گیا ہے۔
حدود
- کلائنٹ کال بیکس ابھی تک سرور پر شروع ہونے والے واقعات کے لیے تعاون یافتہ نہیں ہیں۔
- Pydantic V2 استعمال کرتے وقت OpenAPI دستاویزات تیار نہیں ہوں گی۔ FastAPI pydantic v1 اور v2 نام کی جگہوں کو ملانے کی حمایت نہیں کرتا ہے۔ مزید تفصیلات کے لیے نیچے دیے گئے سیکشن کو دیکھیں۔
LangServe پروجیکٹ کو تیزی سے بوٹسٹریپ کرنے کے لیے LangChain CLI استعمال کریں۔ langchain CLI استعمال کرنے کے لیے، یقینی بنائیں کہ آپ کے پاس langchain-cli کا حالیہ ورژن انسٹال ہے۔ آپ اسے pip install -U langchain-cli کے ساتھ انسٹال کر سکتے ہیں۔
langchain app new ../path/to/directory
LangChain ٹیمپلیٹس کے ساتھ اپنی LangServe مثال کو تیزی سے شروع کریں۔ مزید مثالوں کے لیے، ٹیمپلیٹس انڈیکس یا مثالوں کی ڈائرکٹری دیکھیں۔
یہاں ایک سرور ہے جو ایک OpenAI چیٹ ماڈل، ایک Anthropic چیٹ ماڈل، اور ایک سلسلہ جو Anthropic ماڈل کو کسی موضوع کے بارے میں لطیفہ سنانے کے لیے استعمال کرتا ہے۔
#!/usr/bin/env python
from fastapi import FastAPI
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatAnthropic, ChatOpenAI
from langserve import add_routes app = FastAPI( title="LangChain Server", version="1.0", description="A simple api server using Langchain's Runnable interfaces",
) add_routes( app, ChatOpenAI(), path="/openai",
) add_routes( app, ChatAnthropic(), path="/anthropic",
) model = ChatAnthropic()
prompt = ChatPromptTemplate.from_template("tell me a joke about {topic}")
add_routes( app, prompt | model, path="/chain",
) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="localhost", port=8000)
ایک بار جب آپ اوپر والے سرور کو تعینات کر لیتے ہیں، تو آپ اس کا استعمال کرتے ہوئے تیار کردہ OpenAPI دستاویزات دیکھ سکتے ہیں:
curl localhost:8000/docs
/docs لاحقہ شامل کرنا یقینی بنائیں۔
from langchain.schema import SystemMessage, HumanMessage
from langchain.prompts import ChatPromptTemplate
from langchain.schema.runnable import RunnableMap
from langserve import RemoteRunnable openai = RemoteRunnable("http://localhost:8000/openai/")
anthropic = RemoteRunnable("http://localhost:8000/anthropic/")
joke_chain = RemoteRunnable("http://localhost:8000/chain/") joke_chain.invoke({"topic": "parrots"}) # or async
await joke_chain.ainvoke({"topic": "parrots"}) prompt = [ SystemMessage(content='Act like either a cat or a parrot.'), HumanMessage(content='Hello!')
] # Supports astream
async for msg in anthropic.astream(prompt): print(msg, end="", flush=True) prompt = ChatPromptTemplate.from_messages( [("system", "Tell me a long story about {topic}")]
) # Can define custom chains
chain = prompt | RunnableMap({ "openai": openai, "anthropic": anthropic,
}) chain.batch([{ "topic": "parrots" }, { "topic": "cats" }])
TypeScript میں (LangChain.js ورژن 0.0.166 یا بعد کی ضرورت ہے):
import { RemoteRunnable } from "langchain/runnables/remote"; const chain = new RemoteRunnable({ url: `http://localhost:8000/chain/invoke/`,
});
const result = await chain.invoke({ topic: "cats",
});
درخواستوں کا استعمال کرتے ہوئے ازگر:
import requests
response = requests.post( "http://localhost:8000/chain/invoke/", json={'input': {'topic': 'cats'}}
)
response.json()
آپ curl بھی استعمال کر سکتے ہیں:
curl --location --request POST 'http://localhost:8000/chain/invoke/' --header 'Content-Type: application/json' --data-raw '{ "input": { "topic": "cats" } }'
درج ذیل کوڈ:
...
add_routes( app, runnable, path="/my_runnable",
)
سرور میں ان اختتامی پوائنٹس کا اضافہ کرتا ہے:
- POST/my_runnable/invoke - ایک ہی ان پٹ پر رن ایبل کی درخواست کریں۔
- POST/my_runnable/batch - رن ایبل کو ان پٹ کے بیچ پر مدعو کریں
- POST/my_runnable/stream - ایک ہی ان پٹ پر درخواست کریں اور آؤٹ پٹ کو اسٹریم کریں۔
- POST /my_runnable/stream_log - ایک ہی ان پٹ پر درخواست کریں اور آؤٹ پٹ کو اسٹریم کریں، بشمول درمیانی مراحل کا آؤٹ پٹ جیسا کہ یہ تیار ہوتا ہے۔
- GET /my_runnable/input_schema - رن ایبل میں ان پٹ کے لیے json اسکیما
- GET /my_runnable/output_schema - رن ایبل کے آؤٹ پٹ کے لیے json اسکیما
- GET /my_runnable/config_schema - رن ایبل کی تشکیل کے لیے json اسکیما
آپ اپنے رن ایبل کے لیے کھیل کے میدان کا صفحہ /my_runnable/playground پر تلاش کر سکتے ہیں۔ یہ اسٹریمنگ آؤٹ پٹ اور انٹرمیڈیٹ اقدامات کے ساتھ آپ کے رن ایبل کو کنفیگر کرنے اور شروع کرنے کے لیے ایک سادہ UI کو بے نقاب کرتا ہے۔
کلائنٹ اور سرور دونوں کے لیے:
pip install "langserve[all]"
یا کلائنٹ کوڈ کے لیے pip انسٹال "langserve[client]"، اور pip install "langserve[server]" سرور کوڈ کے لیے۔
اگر آپ کو اپنے سرور میں تصدیق شامل کرنے کی ضرورت ہے، تو براہ کرم FastAPI کی سیکیورٹی دستاویزات اور مڈل ویئر دستاویزات کا حوالہ دیں۔
آپ درج ذیل کمانڈ کا استعمال کرتے ہوئے GCP کلاؤڈ رن پر تعینات کر سکتے ہیں:
gcloud run deploy [your-service-name] --source . --port 8001 --allow-unauthenticated --region us-central1 --set-env-vars=OPENAI_API_KEY=your_key
LangServe کچھ حدود کے ساتھ Pydantic 2 کے لیے مدد فراہم کرتا ہے۔ Pydantic V2 استعمال کرتے وقت invoke/batch/stream/stream_log کے لیے OpenAPI دستاویزات تیار نہیں کیے جائیں گے۔ فاسٹ API pydantic v1 اور v2 نام کی جگہوں کو ملانے کی حمایت نہیں کرتا ہے۔ LangChain Pydantic v1 میں v2 نام کی جگہ استعمال کرتا ہے۔ LangChain کے ساتھ مطابقت کو یقینی بنانے کے لیے براہ کرم درج ذیل ہدایات پڑھیں۔ ان حدود کے علاوہ، ہم توقع کرتے ہیں کہ API کے اختتامی پوائنٹس، کھیل کے میدان، اور کوئی دوسری خصوصیات حسب توقع کام کریں گی۔
ایل ایل ایم ایپلی کیشنز اکثر فائلوں سے نمٹتی ہیں۔ فائل پروسیسنگ کو نافذ کرنے کے لیے مختلف فن تعمیرات بنائے جا سکتے ہیں۔ اعلی سطح پر:
- فائل کو ایک وقف شدہ اختتامی نقطہ کے ذریعے سرور پر اپ لوڈ کیا جا سکتا ہے اور ایک علیحدہ اختتامی نقطہ کا استعمال کرتے ہوئے اس پر کارروائی کی جا سکتی ہے۔
- فائل کو یا تو قدر (فائل کے بائٹس) یا حوالہ (مثلاً، فائل کے مواد میں s3 url) کے ذریعے اپ لوڈ کیا جا سکتا ہے۔
- پروسیسنگ اینڈ پوائنٹ بلاک یا نان بلاکنگ ہو سکتا ہے۔
- اگر اہم پروسیسنگ کی ضرورت ہو تو، پروسیسنگ کو ایک وقف شدہ پروسیسنگ پول میں آف لوڈ کیا جا سکتا ہے۔
آپ کو یہ طے کرنا چاہیے کہ آپ کی درخواست کے لیے مناسب فن تعمیر کیا ہے۔ فی الحال، فائلوں کو قابل قدر میں اپ لوڈ کرنے کے لیے، فائل کے لیے بیس 64 انکوڈنگ کا استعمال کریں (ملٹی پارٹ/فارم-ڈیٹا ابھی تک تعاون یافتہ نہیں ہے)۔
یہ ہے ایک مثال کے طور پر اس سے پتہ چلتا ہے کہ ریموٹ رن ایبل پر فائل بھیجنے کے لیے بیس 64 انکوڈنگ کا استعمال کیسے کیا جائے۔ یاد رکھیں، آپ ہمیشہ فائلوں کو حوالہ کے ذریعے اپ لوڈ کر سکتے ہیں (مثال کے طور پر، s3 url) یا انہیں ملٹی پارٹ/فارم-ڈیٹا کے طور پر ایک وقف شدہ اختتامی نقطہ پر اپ لوڈ کر سکتے ہیں۔
تمام رن ایبلز پر ان پٹ اور آؤٹ پٹ کی اقسام کی وضاحت کی گئی ہے۔ آپ ان تک رسائی input_schema اور output_schema خصوصیات کے ذریعے کر سکتے ہیں۔ LangServe ان اقسام کو توثیق اور دستاویزات کے لیے استعمال کرتا ہے۔ اگر آپ پہلے سے طے شدہ تخمینہ شدہ اقسام کو اوور رائڈ کرنا چاہتے ہیں تو آپ with_types طریقہ استعمال کر سکتے ہیں۔
خیال کو واضح کرنے کے لیے یہاں ایک کھلونا مثال ہے:
from typing import Any
from fastapi import FastAPI
from langchain.schema.runnable import RunnableLambda app = FastAPI() def func(x: Any) -> int: """Mistyped function that should accept an int but accepts anything.""" return x + 1 runnable = RunnableLambda(func).with_types( input_schema=int,
) add_routes(app, runnable)
CustomUserType سے وراثت میں حاصل کریں اگر آپ چاہتے ہیں کہ ڈیٹا کو مساوی ڈکٹ کی نمائندگی کے بجائے پیڈینٹک ماڈل میں ڈی سیریلائز کیا جائے۔ اس وقت، یہ قسم صرف سرور کی طرف کام کرتی ہے اور مطلوبہ ضابطہ کشائی کے رویے کی وضاحت کے لیے استعمال ہوتی ہے۔ اگر اس قسم سے وراثت میں ملتی ہے، تو سرور ڈی کوڈ شدہ قسم کو ڈیکٹ میں تبدیل کرنے کے بجائے اسے پیڈینٹک ماڈل کے طور پر رکھے گا۔
from fastapi import FastAPI
from langchain.schema.runnable import RunnableLambda
from langserve import add_routes
from langserve.schema import CustomUserType app = FastAPI() class Foo(CustomUserType): bar: int def func(foo: Foo) -> int: """Sample function that expects a Foo type which is a pydantic model""" assert isinstance(foo, Foo) return foo.bar add_routes(app, RunnableLambda(func), path="/foo")
کھیل کا میدان آپ کو پسدید سے چلانے کے قابل آپ کے لیے حسب ضرورت وجیٹس کی وضاحت کرنے کی اجازت دیتا ہے۔ ایک ویجیٹ فیلڈ لیول پر بیان کیا جاتا ہے اور ان پٹ قسم کے JSON اسکیما کے حصے کے طور پر بھیج دیا جاتا ہے۔ ایک ویجیٹ میں ایک کلید ہونا ضروری ہے جسے قسم کہا جاتا ہے جس کی قدر وجیٹس کی معروف فہرست میں سے ایک ہو۔ دیگر ویجیٹ کیز ان اقدار سے وابستہ ہوں گی جو JSON آبجیکٹ میں راستوں کی وضاحت کرتی ہیں۔
عمومی اسکیما:
type JsonPath = number | string | (number | string)[];
type NameSpacedPath = { title: string; path: JsonPath }; // Using title to mimic json schema, but can use namespace
type OneOfPath = { oneOf: JsonPath[] }; type Widget = { type: string // Some well-known type (e.g., base64file, chat, etc.) [key: string]: JsonPath | NameSpacedPath | OneOfPath;
};
UI پلے گراؤنڈ میں فائل اپ لوڈ ان پٹ بنانے کی اجازت دیتا ہے ان فائلوں کے لیے جو بیس64 انکوڈ شدہ سٹرنگز کے طور پر اپ لوڈ ہوتی ہیں۔ یہاں مکمل مثال ہے۔
try: from pydantic.v1 import Field
except ImportError: from pydantic import Field from langserve import CustomUserType # ATTENTION: Inherit from CustomUserType instead of BaseModel otherwise
# the server will decode it into a dict instead of a pydantic model.
class FileProcessingRequest(CustomUserType): """Request including a base64 encoded file.""" # The extra field is used to specify a widget for the playground UI. file: str = Field(..., extra={"widget": {"type": "base64file"}}) num_chars: int = 100
ہمارے AI سے چلنے والے ورک فلو بلڈر کے ساتھ دستی کاموں اور ورک فلو کو خودکار بنائیں، جسے Nanonets نے آپ اور آپ کی ٹیموں کے لیے ڈیزائن کیا ہے۔
لینگ سمتھ کا تعارف
LangChain LLM ایپلیکیشنز اور ایجنٹوں کو پروٹو ٹائپ کرنا آسان بناتا ہے۔ تاہم، LLM ایپلیکیشنز کو پروڈکشن تک پہنچانا دھوکے سے مشکل ہو سکتا ہے۔ اعلیٰ معیار کی پروڈکٹ بنانے کے لیے آپ کو ممکنہ طور پر اپنے اشارے، زنجیروں اور دیگر اجزاء پر بہت زیادہ تخصیص اور اعادہ کرنا پڑے گا۔
اس عمل میں مدد کرنے کے لیے، LangSmith کو متعارف کرایا گیا تھا، جو آپ کی LLM ایپلیکیشنز کی ڈیبگنگ، جانچ اور نگرانی کے لیے ایک متحد پلیٹ فارم ہے۔
یہ کب کام آ سکتا ہے؟ آپ کو یہ مفید معلوم ہو سکتا ہے جب آپ کسی نئی چین، ایجنٹ، یا ٹولز کے سیٹ کو تیزی سے ڈیبگ کرنا چاہتے ہیں، تصور کریں کہ اجزاء (زنجیروں، llms، retrievers، وغیرہ) کس طرح آپس میں جڑے ہوئے ہیں اور استعمال کیے جاتے ہیں، ایک جزو کے لیے مختلف اشارے اور LLM کا جائزہ لیں، ڈیٹاسیٹ پر ایک دی گئی چین کو کئی بار چلائیں تاکہ یہ یقینی بنایا جا سکے کہ یہ مستقل طور پر معیاری بار پر پورا اترتا ہے، یا استعمال کے نشانات کیپچر کریں اور بصیرت پیدا کرنے کے لیے LLMs یا اینالیٹکس پائپ لائنز کا استعمال کریں۔
لازمی شرائط:
- ایک LangSmith اکاؤنٹ بنائیں اور ایک API کلید بنائیں (نیچے بائیں کونے کو دیکھیں)۔
- دستاویزات کو دیکھ کر اپنے آپ کو پلیٹ فارم سے آشنا کریں۔
اب ، آئیے شروع کریں!
سب سے پہلے، اپنے ماحول کے متغیرات کو LangChain کو لاگ ان کرنے کے لیے بتانے کے لیے ترتیب دیں۔ یہ LANGCHAIN_TRACING_V2 ماحولیاتی متغیر کو درست پر سیٹ کر کے کیا جاتا ہے۔ آپ LANGCHAIN_PROJECT ماحولیاتی متغیر کو ترتیب دے کر LangChain کو بتا سکتے ہیں کہ کس پروجیکٹ میں لاگ ان کرنا ہے (اگر یہ سیٹ نہیں ہے تو، رنز ڈیفالٹ پروجیکٹ میں لاگ ان ہوں گے)۔ اگر یہ موجود نہیں ہے تو یہ خود بخود آپ کے لیے پروجیکٹ بنا دے گا۔ آپ کو LANGCHAIN_ENDPOINT اور LANGCHAIN_API_KEY ماحولیاتی متغیرات بھی سیٹ کرنا ہوں گے۔
نوٹ: آپ python میں سیاق و سباق کے مینیجر کا استعمال کرتے ہوئے نشانات کو لاگ کرنے کے لیے استعمال کر سکتے ہیں:
from langchain.callbacks.manager import tracing_v2_enabled with tracing_v2_enabled(project_name="My Project"): agent.run("How many people live in canada as of 2023?")
تاہم، اس مثال میں، ہم ماحولیاتی متغیرات استعمال کریں گے۔
%pip install openai tiktoken pandas duckduckgo-search --quiet import os
from uuid import uuid4 unique_id = uuid4().hex[0:8]
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_PROJECT"] = f"Tracing Walkthrough - {unique_id}"
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
os.environ["LANGCHAIN_API_KEY"] = "<YOUR-API-KEY>" # Update to your API key # Used by the agent in this tutorial
os.environ["OPENAI_API_KEY"] = "<YOUR-OPENAI-API-KEY>"
API کے ساتھ تعامل کرنے کے لیے LangSmith کلائنٹ بنائیں:
from langsmith import Client client = Client()
ایک LangChain جزو بنائیں اور پلیٹ فارم پر لاگ ان کریں۔ اس مثال میں، ہم ایک عام سرچ ٹول (DuckDuckGo) تک رسائی کے ساتھ ReAct طرز کا ایجنٹ بنائیں گے۔ ایجنٹ کا اشارہ یہاں حب میں دیکھا جا سکتا ہے:
from langchain import hub
from langchain.agents import AgentExecutor
from langchain.agents.format_scratchpad import format_to_openai_function_messages
from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
from langchain.chat_models import ChatOpenAI
from langchain.tools import DuckDuckGoSearchResults
from langchain.tools.render import format_tool_to_openai_function # Fetches the latest version of this prompt
prompt = hub.pull("wfh/langsmith-agent-prompt:latest") llm = ChatOpenAI( model="gpt-3.5-turbo-16k", temperature=0,
) tools = [ DuckDuckGoSearchResults( name="duck_duck_go" ), # General internet search using DuckDuckGo
] llm_with_tools = llm.bind(functions=[format_tool_to_openai_function(t) for t in tools]) runnable_agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_function_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser()
) agent_executor = AgentExecutor( agent=runnable_agent, tools=tools, handle_parsing_errors=True
)
تاخیر کو کم کرنے کے لیے ہم ایک سے زیادہ ان پٹ پر بیک وقت ایجنٹ چلا رہے ہیں۔ رن پس منظر میں لینگ سمتھ پر لاگ ان ہو جاتے ہیں، اس لیے عملدرآمد میں تاخیر غیر متاثر ہوتی ہے:
inputs = [ "What is LangChain?", "What's LangSmith?", "When was Llama-v2 released?", "What is the langsmith cookbook?", "When did langchain first announce the hub?",
] results = agent_executor.batch([{"input": x} for x in inputs], return_exceptions=True) results[:2]
یہ فرض کرتے ہوئے کہ آپ نے اپنا ماحول کامیابی کے ساتھ ترتیب دیا ہے، آپ کے ایجنٹ کے نشانات ایپ میں پروجیکٹس سیکشن میں ظاہر ہونے چاہئیں۔ مبارک ہو!
ایسا لگتا ہے کہ ایجنٹ اگرچہ مؤثر طریقے سے ٹولز کا استعمال نہیں کر رہا ہے۔ آئیے اس کا جائزہ لیں تو ہمارے پاس ایک بنیادی لائن ہے۔
لاگنگ رنز کے علاوہ، LangSmith آپ کو اپنی LLM درخواستوں کی جانچ اور جانچ کرنے کی بھی اجازت دیتا ہے۔
اس سیکشن میں، آپ ایک بینچ مارک ڈیٹاسیٹ بنانے کے لیے لینگ اسمتھ سے فائدہ اٹھائیں گے اور ایجنٹ پر AI کی مدد سے تشخیص کاروں کو چلائیں گے۔ آپ چند مراحل میں ایسا کریں گے:
- ایک LangSmith ڈیٹاسیٹ بنائیں:
ذیل میں، ہم اوپر سے آنے والے سوالات اور فہرست لیبلز سے ڈیٹاسیٹ بنانے کے لیے LangSmith کلائنٹ کا استعمال کرتے ہیں۔ آپ ان کو بعد میں نئے ایجنٹ کی کارکردگی کی پیمائش کے لیے استعمال کریں گے۔ ڈیٹاسیٹ مثالوں کا ایک مجموعہ ہے، جو ان پٹ آؤٹ پٹ جوڑوں کے علاوہ کچھ نہیں ہے جسے آپ اپنی درخواست کے ٹیسٹ کیس کے طور پر استعمال کر سکتے ہیں:
outputs = [ "LangChain is an open-source framework for building applications using large language models. It is also the name of the company building LangSmith.", "LangSmith is a unified platform for debugging, testing, and monitoring language model applications and agents powered by LangChain", "July 18, 2023", "The langsmith cookbook is a github repository containing detailed examples of how to use LangSmith to debug, evaluate, and monitor large language model-powered applications.", "September 5, 2023",
] dataset_name = f"agent-qa-{unique_id}" dataset = client.create_dataset( dataset_name, description="An example dataset of questions over the LangSmith documentation.",
) for query, answer in zip(inputs, outputs): client.create_example( inputs={"input": query}, outputs={"output": answer}, dataset_id=dataset.id )
- بینچ مارک کے لیے ایک نیا ایجنٹ شروع کریں:
LangSmith آپ کو کسی بھی LLM، چین، ایجنٹ، یا یہاں تک کہ کسی حسب ضرورت فنکشن کا جائزہ لینے دیتا ہے۔ بات چیت کرنے والے ایجنٹ ریاستی ہوتے ہیں (ان کی یادداشت ہوتی ہے)؛ اس بات کو یقینی بنانے کے لیے کہ اس حالت کو ڈیٹاسیٹ کے درمیان اشتراک نہیں کیا گیا ہے، ہم ایک chain_factory میں گزریں گے (
عرف کنسٹرکٹر) فنکشن ہر کال کے لیے شروع کرنے کے لیے:
# Since chains can be stateful (e.g. they can have memory), we provide
# a way to initialize a new chain for each row in the dataset. This is done
# by passing in a factory function that returns a new chain for each row.
def agent_factory(prompt): llm_with_tools = llm.bind( functions=[format_tool_to_openai_function(t) for t in tools] ) runnable_agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_function_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser() ) return AgentExecutor(agent=runnable_agent, tools=tools, handle_parsing_errors=True)
- تشخیص کو ترتیب دیں:
UI میں زنجیروں کے نتائج کا دستی طور پر موازنہ مؤثر ہے، لیکن اس میں وقت لگ سکتا ہے۔ آپ کے اجزاء کی کارکردگی کا جائزہ لینے کے لیے خودکار میٹرکس اور AI کی مدد سے فیڈ بیک استعمال کرنا مددگار ثابت ہو سکتا ہے:
from langchain.evaluation import EvaluatorType
from langchain.smith import RunEvalConfig evaluation_config = RunEvalConfig( evaluators=[ EvaluatorType.QA, EvaluatorType.EMBEDDING_DISTANCE, RunEvalConfig.LabeledCriteria("helpfulness"), RunEvalConfig.LabeledScoreString( { "accuracy": """
Score 1: The answer is completely unrelated to the reference.
Score 3: The answer has minor relevance but does not align with the reference.
Score 5: The answer has moderate relevance but contains inaccuracies.
Score 7: The answer aligns with the reference but has minor errors or omissions.
Score 10: The answer is completely accurate and aligns perfectly with the reference.""" }, normalize_by=10, ), ], custom_evaluators=[],
)
- ایجنٹ اور تشخیص کاروں کو چلائیں:
اپنے ماڈل کا جائزہ لینے کے لیے run_on_dataset (یا غیر مطابقت پذیر arun_on_dataset) فنکشن استعمال کریں۔ یہ کرے گا:
- مخصوص ڈیٹا سیٹ سے مثال کی قطاریں حاصل کریں۔
- ہر مثال پر اپنا ایجنٹ (یا کوئی کسٹم فنکشن) چلائیں۔
- خودکار تاثرات پیدا کرنے کے لیے نتیجے میں رن ٹریسز اور متعلقہ حوالہ مثالوں پر تشخیص کاروں کا اطلاق کریں۔
نتائج LangSmith ایپ میں نظر آئیں گے:
chain_results = run_on_dataset( dataset_name=dataset_name, llm_or_chain_factory=functools.partial(agent_factory, prompt=prompt), evaluation=evaluation_config, verbose=True, client=client, project_name=f"runnable-agent-test-5d466cbc-{unique_id}", tags=[ "testing-notebook", "prompt:5d466cbc", ],
)
اب جب کہ ہمارے پاس اپنے ٹیسٹ رن کے نتائج ہیں، ہم اپنے ایجنٹ میں تبدیلیاں کر سکتے ہیں اور انہیں بینچ مارک کر سکتے ہیں۔ آئیے اسے ایک مختلف اشارے کے ساتھ دوبارہ آزمائیں اور نتائج دیکھیں:
candidate_prompt = hub.pull("wfh/langsmith-agent-prompt:39f3bbd0") chain_results = run_on_dataset( dataset_name=dataset_name, llm_or_chain_factory=functools.partial(agent_factory, prompt=candidate_prompt), evaluation=evaluation_config, verbose=True, client=client, project_name=f"runnable-agent-test-39f3bbd0-{unique_id}", tags=[ "testing-notebook", "prompt:39f3bbd0", ],
)
LangSmith آپ کو عام فارمیٹس جیسے CSV یا JSONL میں براہ راست ویب ایپ میں ڈیٹا ایکسپورٹ کرنے دیتا ہے۔ آپ کلائنٹ کو مزید تجزیہ کرنے، اپنے ڈیٹا بیس میں اسٹور کرنے یا دوسروں کے ساتھ شیئر کرنے کے لیے بھی استعمال کر سکتے ہیں۔ آئیے ایویلیویشن رن سے رن کے نشانات حاصل کریں:
runs = client.list_runs(project_name=chain_results["project_name"], execution_order=1) # After some time, these will be populated.
client.read_project(project_name=chain_results["project_name"]).feedback_stats
یہ شروع کرنے کے لیے ایک فوری گائیڈ تھی، لیکن آپ کے ڈویلپر کے بہاؤ کو تیز کرنے اور بہتر نتائج پیدا کرنے کے لیے LangSmith کو استعمال کرنے کے اور بھی بہت سے طریقے ہیں۔
اس بارے میں مزید معلومات کے لیے کہ آپ کس طرح لینگ سمتھ سے زیادہ سے زیادہ فائدہ اٹھا سکتے ہیں، لینگ سمتھ کی دستاویزات دیکھیں۔
Nanonets کے ساتھ لیول اپ
اگرچہ LangChain آپ کی ایپلی کیشنز کے ساتھ لینگویج ماڈلز (LLMs) کو مربوط کرنے کے لیے ایک قابل قدر ٹول ہے، لیکن جب انٹرپرائز استعمال کے معاملات کی بات آتی ہے تو اسے حدود کا سامنا کرنا پڑ سکتا ہے۔ آئیے دریافت کریں کہ ان چیلنجوں سے نمٹنے کے لیے نانونیٹ کس طرح لینگ چین سے آگے بڑھتے ہیں:
1. جامع ڈیٹا کنیکٹوٹی:
LangChain کنیکٹرز پیش کرتا ہے، لیکن ہو سکتا ہے کہ یہ تمام ورک اسپیس ایپس اور ڈیٹا فارمیٹس کا احاطہ نہ کرے جن پر کاروبار انحصار کرتے ہیں۔ Nanonets 100 سے زیادہ وسیع پیمانے پر استعمال ہونے والی ورک اسپیس ایپس کے لیے ڈیٹا کنیکٹر فراہم کرتا ہے، بشمول Slack، Notion، Google Suite، Salesforce، Zendesk، اور بہت کچھ۔ یہ تمام غیر ساختہ ڈیٹا کی قسموں جیسے PDFs، TXTs، تصاویر، آڈیو فائلز، اور ویڈیو فائلوں کے ساتھ ساتھ CSVs، اسپریڈ شیٹس، MongoDB، اور SQL ڈیٹا بیس جیسے سٹرکچرڈ ڈیٹا کی اقسام کو بھی سپورٹ کرتا ہے۔
2. ورک اسپیس ایپس کے لیے ٹاسک آٹومیشن:
اگرچہ متن/ رسپانس جنریشن بہت اچھا کام کرتی ہے، لیکن جب مختلف ایپلی کیشنز میں کام انجام دینے کے لیے قدرتی زبان استعمال کرنے کی بات آتی ہے تو LangChain کی صلاحیتیں محدود ہوتی ہیں۔ Nanonets مقبول ترین ورک اسپیس ایپس کے لیے ٹرگر/ایکشن ایجنٹس پیش کرتا ہے، جس سے آپ کو ایسے ورک فلو سیٹ اپ کرنے کی اجازت ملتی ہے جو ایونٹس کو سنتے ہیں اور اعمال انجام دیتے ہیں۔ مثال کے طور پر، آپ ای میل کے جوابات، CRM اندراجات، SQL استفسارات، اور بہت کچھ، قدرتی زبان کے حکموں کے ذریعے خودکار کر سکتے ہیں۔
3. ریئل ٹائم ڈیٹا سنک:
LangChain ڈیٹا کنیکٹرز کے ساتھ جامد ڈیٹا لاتا ہے، جو ماخذ ڈیٹا بیس میں ڈیٹا کی تبدیلیوں کو برقرار نہیں رکھ سکتا۔ اس کے برعکس، Nanonets ڈیٹا کے ذرائع کے ساتھ ریئل ٹائم ہم آہنگی کو یقینی بناتا ہے، اس بات کو یقینی بناتا ہے کہ آپ ہمیشہ تازہ ترین معلومات کے ساتھ کام کر رہے ہیں۔
3. آسان ترتیب:
LangChain پائپ لائن کے عناصر کو ترتیب دینا، جیسے کہ بازیافت کرنے والے اور سنتھیسائزرز، ایک پیچیدہ اور وقت طلب عمل ہوسکتا ہے۔ Nanonets ہر ڈیٹا کی قسم کے لیے بہترین ڈیٹا انجیشن اور انڈیکسنگ فراہم کر کے اس کو ہموار کرتا ہے، یہ سب AI اسسٹنٹ کے ذریعے پس منظر میں ہینڈل کیا جاتا ہے۔ اس سے فائن ٹیوننگ کا بوجھ کم ہو جاتا ہے اور سیٹ اپ اور استعمال میں آسانی ہوتی ہے۔
4. متحد حل:
LangChain کے برعکس، جس میں ہر کام کے لیے منفرد نفاذ کی ضرورت پڑ سکتی ہے، Nanonets آپ کے ڈیٹا کو LLMs کے ساتھ مربوط کرنے کے لیے ایک ون اسٹاپ حل کے طور پر کام کرتا ہے۔ چاہے آپ کو LLM ایپلی کیشنز بنانے کی ضرورت ہو یا AI ورک فلوز، Nanonets آپ کی متنوع ضروریات کے لیے ایک متحد پلیٹ فارم پیش کرتا ہے۔
Nanonets AI ورک فلوز
Nanonets Workflows ایک محفوظ، کثیر مقصدی AI اسسٹنٹ ہے جو LLMs کے ساتھ آپ کے علم اور ڈیٹا کے انضمام کو آسان بناتا ہے اور بغیر کوڈ ایپلی کیشنز اور ورک فلوز کی تخلیق میں سہولت فراہم کرتا ہے۔ یہ استعمال میں آسان یوزر انٹرفیس پیش کرتا ہے، جو اسے افراد اور تنظیموں دونوں کے لیے قابل رسائی بناتا ہے۔
شروع کرنے کے لیے، آپ ہمارے AI ماہرین میں سے کسی کے ساتھ کال کا شیڈول بنا سکتے ہیں، جو آپ کے مخصوص استعمال کے معاملے کے مطابق Nanonets Workflows کا ذاتی نوعیت کا ڈیمو اور ٹرائل فراہم کر سکتا ہے۔
ایک بار سیٹ اپ ہونے کے بعد، آپ اپنی ایپس اور ڈیٹا کے ساتھ بغیر کسی رکاوٹ کے انضمام کرتے ہوئے، پیچیدہ ایپلیکیشنز اور LLM کے ذریعے چلنے والے ورک فلو کو ڈیزائن اور ان پر عمل کرنے کے لیے قدرتی زبان کا استعمال کر سکتے ہیں۔
ایپس بنانے اور اپنے ڈیٹا کو AI سے چلنے والی ایپلیکیشنز اور ورک فلو کے ساتھ مربوط کرنے کے لیے Nanonets AI کے ساتھ اپنی ٹیموں کو سپرچارج کریں، جس سے آپ کی ٹیموں کو اس بات پر توجہ مرکوز کرنے کی اجازت دی جائے جو واقعی اہم ہے۔
ہمارے AI سے چلنے والے ورک فلو بلڈر کے ساتھ دستی کاموں اور ورک فلو کو خودکار بنائیں، جسے Nanonets نے آپ اور آپ کی ٹیموں کے لیے ڈیزائن کیا ہے۔
- SEO سے چلنے والا مواد اور PR کی تقسیم۔ آج ہی بڑھا دیں۔
- پلیٹو ڈیٹا ڈاٹ نیٹ ورک ورٹیکل جنریٹو اے آئی۔ اپنے آپ کو بااختیار بنائیں۔ یہاں تک رسائی حاصل کریں۔
- پلیٹوآئ اسٹریم۔ ویب 3 انٹیلی جنس۔ علم میں اضافہ۔ یہاں تک رسائی حاصل کریں۔
- پلیٹو ای ایس جی۔ کاربن، کلین ٹیک، توانائی ، ماحولیات، شمسی، ویسٹ مینجمنٹ یہاں تک رسائی حاصل کریں۔
- پلیٹو ہیلتھ۔ بائیوٹیک اینڈ کلینیکل ٹرائلز انٹیلی جنس۔ یہاں تک رسائی حاصل کریں۔
- ماخذ: https://nanonets.com/blog/langchain/
- : ہے
- : ہے
- : نہیں
- :کہاں
- $UP
- 1
- 10
- 100
- 114
- 13
- 15٪
- 2000
- 2012
- 2023
- 25
- 30
- 32
- 36
- 40
- 400
- 408
- 50
- 500
- 7
- 8
- a
- ABC
- کی صلاحیت
- قابلیت
- ہمارے بارے میں
- اس کے بارے میں
- اوپر
- قبول کریں
- قبول کرتا ہے
- تک رسائی حاصل
- قابل رسائی
- تک رسائی حاصل
- پورا
- اس کے مطابق
- اکاؤنٹ
- درستگی
- درست
- درست طریقے سے
- حاصل
- حاصل کیا
- حاصل کرتا ہے
- کے پار
- ایکٹ
- عمل
- اعمال
- فعال
- اپنانے
- انکولی
- شامل کریں
- شامل کیا
- انہوں نے مزید کہا
- اس کے علاوہ
- ایڈیشنل
- اس کے علاوہ
- پتہ
- جوڑتا ہے
- تسلیم
- اعلی درجے کی
- مہم جوئی
- کے بعد
- پھر
- عمر
- ایجنٹ
- ایجنٹ
- AI
- اے آئی اسسٹنٹ
- اے آئی ماڈلز
- امداد
- مقصد
- یلگوردمز
- سیدھ کریں
- سیدھ میں لائیں
- تمام
- کی اجازت
- اجازت دے رہا ہے
- کی اجازت دیتا ہے
- اکیلے
- ساتھ
- شانہ بشانہ
- پہلے ہی
- بھی
- اگرچہ
- ہمیشہ
- an
- تجزیہ
- تجزیاتی
- تجزیاتی
- اور
- اینجلس
- اعلان کریں
- سالانہ
- ایک اور
- جواب
- جواب
- سرود
- بشری
- کوئی بھی
- کچھ
- اے پی آئی
- API کیز
- APIs
- اپلی کیشن
- قابل اطلاق
- درخواست
- درخواست کی ترقی
- ایپلی کیشنز
- اطلاقی
- لاگو ہوتا ہے
- نقطہ نظر
- نقطہ نظر
- مناسب
- مناسب طریقے سے
- ایپس
- فن تعمیر
- کیا
- دلیل
- دلائل
- آرمسٹرانگ
- ارد گرد
- لڑی
- آرٹسٹ
- AS
- پوچھنا
- پہلو
- پہلوؤں
- مدد
- اسسٹنٹ
- منسلک
- At
- منسلک کریں
- توجہ
- آڈیو
- اضافہ
- کی توثیق
- خود کار طریقے سے
- آٹومیٹڈ
- خودکار
- خود کار طریقے سے
- میشن
- دستیاب
- اوسط
- انتظار کرو
- آگاہ
- AWS
- واپس
- ریڑھ کی ہڈی
- پسدید
- پس منظر
- بری طرح
- متوازن
- بار
- بیس
- کی بنیاد پر
- بیس لائن
- مار
- بنیادی
- مبادیات
- بیسیجی
- BE
- بیچ
- ریچھ
- کیونکہ
- رہا
- اس سے پہلے
- شروع کریں
- رویے
- پیچھے
- پردے کے پیچھے
- کیا جا رہا ہے
- نیچے
- معیار
- فائدہ مند
- BEST
- بہتر
- کے درمیان
- سے پرے
- سب سے بڑا
- بل
- بل گیٹس
- باندھنے
- بنگ
- بٹ
- سیاہ
- بلیک ہول
- بلاک
- مسدود کرنے میں
- بلاکس
- بلاگ
- باب
- بوٹسٹریپ
- پیدا
- بوٹ
- دونوں
- پایان
- برانچ
- توڑ
- بیار
- مختصر
- وسیع
- کتتھئ
- براؤزر
- بفر
- تعمیر
- بلڈر
- عمارت
- تعمیر
- بوجھ
- کاروبار
- لیکن
- by
- حساب
- حساب کرتا ہے
- حساب
- حساب سے
- فون
- کال بیکس
- کہا جاتا ہے
- بلا
- کالز
- کر سکتے ہیں
- حاصل کر سکتے ہیں
- کینیڈا
- صلاحیتوں
- صلاحیت رکھتا
- اہلیت
- قبضہ
- گرفتاری
- کیس
- مقدمات
- CAT
- کھانا کھلانا
- کیٹرنگ
- کیٹر
- بلیوں
- احتیاط
- محتاط
- مرکوز
- کچھ
- چین
- زنجیروں
- چیلنجوں
- تبدیلیاں
- کردار
- چیٹ بٹ
- چیٹ بٹس
- چیک کریں
- چیک
- میں سے انتخاب کریں
- منتخب کیا
- حالات
- شہر
- طبقے
- کلاس
- کلائنٹ
- بادل
- کوڈ
- کوڈنگ
- کافی
- مربوط
- ہم آہنگ
- تعاون
- نیست و نابود
- مجموعہ
- رنگا رنگ
- کالم
- کالم
- COM
- جمع
- مل کر
- یکجا
- امتزاج
- کس طرح
- آتا ہے
- آرام دہ اور پرسکون
- کامن
- مواصلات
- کمپنی کے
- موازنہ
- موازنہ
- مطابقت
- ہم آہنگ
- مکمل
- مکمل طور پر
- تکمیل
- پیچیدہ
- پیچیدگیاں
- جزو
- اجزاء
- پر مشتمل
- ساخت
- وسیع
- پر مشتمل ہے
- تصور
- جامع
- سمورتی
- شرط
- ترتیب
- سنگم
- رابطہ قائم کریں
- مربوط
- رابطہ
- خامیاں
- غور کریں
- مسلسل
- مشتمل
- کنسول
- مسلسل
- تعمیرات
- پر مشتمل ہے
- پر مشتمل ہے
- مواد
- سیاق و سباق
- سیاق و سباق
- متعلقہ
- جاری
- مسلسل
- اس کے برعکس
- کنٹرول
- کنٹرول
- آسان
- بات چیت
- سنوادی
- بات چیت AI
- مکالمات
- تبادلوں سے
- تبدیل
- تبدیل کرنا
- کور
- کونے
- درست
- اسی کے مطابق
- سکتا ہے
- گنتی
- ملک
- جوڑے
- احاطہ
- احاطہ کرتا ہے
- تخلیق
- بنائی
- پیدا
- تخلیق
- مخلوق
- اسناد
- معیار
- تنقید
- CRM
- اہم
- موجودہ
- اس وقت
- اپنی مرضی کے
- گاہکوں
- اصلاح
- اپنی مرضی کے مطابق
- اپنی مرضی کے مطابق
- جدید
- اعداد و شمار
- ڈیٹا کی ساخت
- ڈیٹا بیس
- ڈیٹا بیس
- تاریخ
- تاریخ کے وقت
- نمٹنے کے
- معاملہ
- دسمبر
- فیصلہ کرنا
- فیصلہ کرنا
- فیصلہ کرنا
- ضابطہ ربائی کرنا
- وقف
- گہرے
- پہلے سے طے شدہ
- وضاحت
- کی وضاحت
- وضاحت
- تعریفیں
- ترسیل
- فراہم کرتا ہے
- ڈیلے
- ڈیمو
- مظاہرہ
- demonstrated,en
- مظاہرین
- انحصار
- منحصر ہے
- انحصار کرتا ہے
- تعیناتی
- تعینات
- تعینات
- تعیناتی
- تعینات کرتا ہے
- بیان
- تفصیل
- ڈیزائن
- نامزد
- ڈیزائن
- مطلوبہ
- تفصیل
- تفصیلی
- تفصیلات
- اس بات کا تعین
- یہ تعین
- ترقی
- ڈیولپر
- ڈویلپرز
- ترقی
- ترقی
- ڈایاگرام
- DICT
- DID
- مختلف
- مختلف
- مختلف
- مشکل
- طول و عرض
- طول و عرض
- ہدایات
- براہ راست
- بات چیت
- بات چیت
- دکھانا
- مختلف
- ڈوبکی
- متنوع
- DM
- do
- دستاویز
- دستاویزات
- دستاویزات
- کرتا
- نہیں
- کر
- ڈان
- کیا
- دوگنا
- نیچے
- ڈاؤن لوڈ، اتارنا
- ڈاؤن لوڈز
- ڈرافٹ
- ڈرائیو
- دو
- کے دوران
- متحرک
- متحرک طور پر
- e
- ہر ایک
- اس سے قبل
- ابتدائی
- کو کم
- استعمال میں آسانی
- آسان
- آسانی سے
- آسان
- استعمال میں آسان
- یاد آتی ہے
- ماحول
- موثر
- مؤثر طریقے
- کارکردگی
- ہنر
- مؤثر طریقے سے
- محنت سے
- یا تو
- عنصر
- عناصر
- یلون
- یلون کستوری
- اور
- ای میل
- یمبیڈ
- ایمبیڈڈ
- سرایت کرنا
- ملازم
- ملازمین
- ملازمت کرتا ہے
- بااختیار
- کو چالو کرنے کے
- کے قابل بناتا ہے
- کو فعال کرنا
- encapsulates
- مقابلہ کرنا
- آخر سے آخر تک
- اختتام پوائنٹ
- مشغول
- انجن
- انجن
- انگلینڈ
- انگریزی
- انگریزی پریمیئر لیگ
- بڑھانے کے
- بہتر
- بڑھانے
- کو یقینی بنانے کے
- یقینی بناتا ہے
- کو یقینی بنانے ہے
- انٹرپرائز
- اداروں
- ہستی
- ماحولیات
- ماحول
- مساوی
- دور
- خرابی
- نقائص
- خاص طور پر
- ضروری
- اجنبی
- وغیرہ
- اندازہ
- تشخیص
- بھی
- واقعات
- ہر کوئی
- مثال کے طور پر
- مثال کے طور پر
- حد سے تجاوز
- اس کے علاوہ
- عملدرآمد
- پھانسی
- پھانسی
- پھانسی
- پھانسی
- مثال دیتا ہے
- ورزش
- وجود
- توقع ہے
- توقعات
- توقع
- امید ہے
- تجربہ
- تجرباتی
- ماہرین
- وضاحت کی
- بیان کرتا ہے
- واضح طور پر
- کی تلاش
- تلاش
- وضاحت کی
- برآمد
- اظہار
- توسیع
- توسیع
- وسیع
- بیرونی
- اضافی
- نکالنے
- نکالنے
- نچوڑ۔
- چہرہ
- سہولت
- سہولت
- فیکٹری
- حقائق
- دور
- فاسٹ
- پسندیدہ
- نمایاں کریں
- خصوصیات
- آراء
- چند
- میدان
- قطعات
- انجما
- اعداد و شمار
- فائل
- فائلوں
- بھرنے
- بھرے
- بھرنے
- فلٹر
- فلٹرنگ
- فائنل
- آخر
- مل
- تلاش
- پہلا
- پانچ
- لچک
- لچکدار
- بہاؤ
- توجہ مرکوز
- توجہ مرکوز
- توجہ مرکوز
- توجہ مرکوز
- پر عمل کریں
- کے بعد
- مندرجہ ذیل ہے
- کھانا
- کے لئے
- فارم
- فارمیٹ
- تشکیل
- خوش قسمتی سے
- ملا
- فریم ورک
- فریم ورک
- اکثر
- دوست
- دوست
- سے
- مکمل
- مکمل
- تقریب
- افعال
- فعالیت
- افعال
- بنیادی
- عجیب
- مزید
- مستقبل
- حاصل کرنا
- کھیل
- گیٹس
- جنرل
- عام طور پر
- پیدا
- پیدا
- پیدا ہوتا ہے
- پیدا کرنے والے
- نسل
- سٹائل
- جرمنی
- حاصل
- حاصل کرنے
- GIF
- GitHub کے
- دی
- جی ایم ٹی
- Go
- جاتا ہے
- جا
- اچھا
- گوگل
- دانے دار
- گراف
- عظیم
- زیادہ سے زیادہ
- رہنمائی
- رہنمائی
- ہدایات
- ہیکاتھ
- ہینڈل
- ہینڈل
- ہینڈلنگ
- موبائل
- ہارڈ
- نقصان پہنچانے
- استعمال
- ہے
- ہونے
- بھاری
- Held
- مدد
- مدد گار
- مدد کرتا ہے
- اس کی
- یہاں
- hi
- ہائی
- اعلی سطحی
- اعلی معیار کی
- سب سے زیادہ
- انتہائی
- تاریخی
- تاریخ
- چھید
- ہڈ
- میزبان
- کس طرح
- کیسے
- تاہم
- HTML
- HTTP
- HTTPS
- حب
- انسانی
- سینکڑوں
- i
- ID
- خیال
- مثالی
- شناخت
- if
- ii
- III
- وضاحت
- وضاحت کرتا ہے
- تصاویر
- فوری طور پر
- پر عملدرآمد
- نفاذ
- عمل درآمد
- عملدرآمد
- درآمد
- بہتری
- کو بہتر بنانے کے
- in
- میں گہرائی
- شامل
- شامل
- شامل ہیں
- سمیت
- شامل
- شامل کرنا
- ناقابل یقین حد تک
- انڈکس
- انڈیکس
- اشارہ کرتے ہیں
- اشارہ کرتا ہے
- انفرادی طور پر
- افراد
- معلومات
- ابتدائی
- شروع
- جدید
- ان پٹ
- آدانوں
- بصیرت
- انسٹال
- نصب
- انسٹال کرنا
- مثال کے طور پر
- فوری
- کے بجائے
- ہدایات
- اٹوٹ
- ضم
- ضم
- انٹیگریٹٹس
- انضمام کرنا
- انضمام
- انضمام
- انٹیلجنٹ
- ارادہ
- بات چیت
- بات چیت
- بات چیت
- انٹرایکٹو
- انٹرایکٹو
- انٹرفیس
- انٹرفیسز
- اندرونی طور پر
- انٹرنیٹ
- میں
- متعارف
- متعارف کرواتا ہے
- بدیہی
- شامل
- نہیں
- مسئلہ
- مسائل
- IT
- اشیاء
- تکرار
- میں
- خود
- جیکسن
- جاوا سکرپٹ
- ایوب
- اردن
- سفر
- JSON
- جولائی
- صرف
- جسٹس
- رکھیں
- رہتا ہے
- کلیدی
- چابیاں
- بچے
- جان
- علم
- نالج گراف۔
- جانا جاتا ہے
- لیبل
- لیبل
- لینڈ
- زبان
- زبانیں
- بڑے
- بڑے
- آخری
- تاخیر
- بعد
- تازہ ترین
- لیگ
- جانیں
- سیکھنے
- چھوڑ دیا
- کی وراست
- لمبائی
- کم
- دو
- آو ہم
- خط
- سطح
- سطح
- لیوریج
- لیتا ہے
- لیورنگنگ
- لائبریریوں
- لائبریری
- کی طرح
- امکان
- LIMIT
- حدود
- لمیٹڈ
- محدود
- حدود
- لنکس
- لسٹ
- سننے
- فہرستیں
- رہتے ہیں
- ll
- ایل ایل ایم
- لوڈ
- بارک
- واقع ہے
- محل وقوع
- لاگ ان کریں
- انکرنا
- لاگ ان
- منطق
- لانگ
- اب
- دیکھو
- تلاش
- دیکھنا
- تلاش
- ان
- لاس اینجلس
- لو
- مشین
- مشین لرننگ
- بنا
- برقرار رکھنے کے
- برقرار رکھنے کے قابل
- برقرار رکھنے
- برقرار رکھتا ہے
- بنا
- بناتا ہے
- بنانا
- انتظام
- انتظام
- مینیجر
- مینیجنگ
- مانچسٹر
- مانچسٹر یونائیٹڈ
- ہیرا پھیری
- انداز
- دستی
- ڈویلپر
- بہت سے
- بہت سے لوگ
- نقشہ
- تعریفیں
- نقشہ جات
- میچ
- کے ملاپ
- ریاضی
- ریاضیاتی
- معاملات
- زیادہ سے زیادہ
- مئی..
- me
- مطلب
- مطلب
- کا مطلب ہے کہ
- پیمائش
- میڈیا
- اجلاس
- ملتا ہے
- یادیں
- یاد داشت
- ذکر کیا
- ضم کریں
- ضم
- پیغام
- پیغامات
- پیغام رسانی
- میٹا ڈیٹا
- طریقہ
- طریقوں
- پیمائش کا معیار
- شاید
- لاکھوں
- کم سے کم
- معمولی
- لاپتہ
- غلطیوں
- مخلوط
- MLB
- موبائل
- ماڈل
- ماڈل
- اعتدال پسند
- ماڈیول
- ماڈیولز
- لمحہ
- منگو ڈی بی
- کی نگرانی
- نگرانی
- مون
- زیادہ
- سب سے زیادہ
- سب سے زیادہ مقبول
- منتقل
- فلم
- بہت
- ایک سے زیادہ
- متعدد زنجیریں
- کستوری
- ضروری
- my
- نام
- نامزد
- نام
- قومی
- قدرتی
- قدرتی زبان عملیات
- تشریف لے جائیں
- تشریف لے جارہا ہے
- قریب
- ضروری
- ضرورت ہے
- ضرورت
- ضروریات
- منفی
- نئی
- NY
- نیو یارک ٹائمز
- اگلے
- نہیں
- کوئی بھی نہیں
- کچھ بھی نہیں
- تصور
- اب
- تعداد
- اوباما
- اعتراض
- مقصد
- اشیاء
- جائزہ
- حاصل
- حاصل کرنا
- OCR
- of
- پیش کرتے ہیں
- کی پیشکش
- تجویز
- اکثر
- oh
- ٹھیک ہے
- اولمپکس
- on
- ایک بار
- ایک
- صرف
- اوپن سورس
- اوپنائی
- آپریشنز
- آپریٹر
- اصلاح
- اصلاح کرتا ہے
- اختیار
- or
- حکم
- نامیاتی
- تنظیمیں
- اصل
- OS
- دیگر
- دیگر
- دوسری صورت میں
- ہمارے
- باہر
- پیداوار
- نتائج
- پر
- منسوخی
- مجموعی جائزہ
- خود
- پیکج
- پیکجوں کے
- صفحہ
- صفحات
- جوڑے
- pandas
- کاغذ.
- متوازی
- پیرامیٹر
- پیرامیٹرز
- پارک
- حصہ
- خاص طور پر
- حصے
- منظور
- منظور
- گزرتا ہے
- پاسنگ
- گزشتہ
- راستہ
- راستے
- پیٹرن
- پے رول
- لوگ
- فی
- کامل
- بالکل
- انجام دیں
- کارکردگی
- کارکردگی کا مظاہرہ
- کارکردگی کا مظاہرہ
- اجازتیں
- مسلسل
- انسان
- نجیکرت
- نقطہ نظر
- طبعیات
- ٹکڑا
- پائپ لائن
- پزا
- پلیس ہولڈر
- پلیٹ فارم
- پلاٹا
- افلاطون ڈیٹا انٹیلی جنس
- پلیٹو ڈیٹا
- کھیلیں
- کھیل کے میدان
- ادا کرتا ہے
- مہربانی کرکے
- علاوہ
- پوائنٹ
- پالیسیاں
- پالیسی
- سیاسی
- پول
- مقبول
- آباد ہے
- مثبت
- ممکن
- پوسٹ
- مراسلات
- ممکنہ
- طاقت
- طاقت
- طاقتور
- عملی
- پریکٹس
- کو ترجیح دیتے ہیں
- وزیر اعظم
- حال (-)
- صدر
- کی روک تھام
- کی روک تھام
- پچھلا
- بنیادی طور پر
- پرائمری
- وزیر اعظم
- نجی
- مسئلہ
- مسائل
- آگے بڑھو
- عمل
- عملدرآمد
- عمل
- پروسیسنگ
- پیدا
- مصنوعات
- پیداوار
- ٹیچر
- پروگرامنگ
- پروگرامنگ زبانوں
- منصوبے
- منصوبوں
- خصوصیات
- جائیداد
- پیشہ
- پروٹوٹائپ
- prototyping کے
- فراہم
- فراہم
- فراہم کنندہ
- فراہم کرنے والے
- فراہم کرتا ہے
- فراہم کرنے
- عوامی
- مقصد
- مقاصد
- ڈال
- ازگر
- سوال و جواب
- معیار
- سوالات
- سوال
- سوالات
- فوری
- جلدی سے
- واوین
- R
- بلند
- رینج
- لے کر
- بلکہ
- درجہ بندی
- خام
- RE
- تک پہنچنے
- جواب دیں
- پڑھیں
- پڑھنا
- تیار
- اصلی
- اصل وقت
- اصل وقت کا ڈیٹا
- دائرے میں
- وجہ
- وجوہات
- حال ہی میں
- سفارش کی
- درج
- ریکارڈ
- بازیافت
- کو کم
- کم
- کو کم کرنے
- کمی
- حوالہ
- حوالہ دینا۔
- بہتر
- ادائیگی
- خطوں
- تعلقات
- جاری
- مطابقت
- متعلقہ
- وشوسنییتا
- قابل اعتماد
- انحصار کرو
- یقین ہے
- باقی
- یاد
- یاد دہانی
- ریموٹ
- برآمد
- دوبارہ
- بار بار
- ریفریجنگ
- کی جگہ
- رپورٹ
- ذخیرہ
- نمائندگی
- نمائندگی
- کی نمائندگی کرتا ہے
- درخواست
- درخواستوں
- کی ضرورت
- ضرورت
- ضروریات
- کی ضرورت ہے
- بچانے
- تحقیق
- حل
- وسائل
- جواب
- جواب دیں
- جواب
- جوابات
- ذمہ دار
- قبول
- باقی
- نتیجہ
- نتیجے
- نتائج کی نمائش
- برقرار رکھنے
- برقراری
- واپسی
- واپس لوٹنے
- واپسی
- قابل اعتماد
- کا جائزہ لینے کے
- گھومتا ہے
- رائس
- امیر
- روبوٹس
- کردار
- کردار
- جڑ
- روٹنگ
- ROW
- رن
- چل رہا ہے
- چلتا ہے
- رن ٹائم
- s
- تحفظات
- فروخت
- فروختforce
- سیم
- اسی
- محفوظ کریں
- کا کہنا ہے کہ
- کا کہنا ہے کہ
- توسیع پذیر
- پیمانے
- منظر نامے
- منظرنامے
- مناظر
- شیڈول
- سکور
- فیرنا
- ہموار
- بغیر کسی رکاوٹ کے
- تلاش کریں
- تلاش کے انجن
- تلاش
- تلاش
- سیکشن
- سیکشنز
- محفوظ بنانے
- سیکورٹی
- دیکھنا
- منتخب
- انتخاب
- فروخت
- بھیجنے
- حساس
- جذبات
- احساسات
- علیحدہ
- ستمبر
- تسلسل
- سیریز
- خدمت
- سرور
- کام کرتا ہے
- سروسز
- مقرر
- سیٹ
- قائم کرنے
- ترتیبات
- سیٹ اپ
- سات
- کئی
- سیکنڈ اور
- مشترکہ
- شیل
- چمکتا ہے
- بھیج دیا
- ہونا چاہئے
- دکھائیں
- نمائش
- دکھایا گیا
- شوز
- سگما
- اہم
- اسی طرح
- سادہ
- آسان
- آسان بنانے
- آسان بنانا
- صرف
- بعد
- ایک
- سائز
- سست
- چھوٹے
- چھوٹے
- ہوشیار
- ٹکڑا
- So
- اب تک
- فٹ بال
- سماجی
- سوشل میڈیا
- سوشل میڈیا پوسٹس
- مکمل طور پر
- ٹھوس
- حل
- حل
- کچھ
- کچھ
- کبھی کبھی
- بہتر
- آواز
- ماخذ
- ذرائع
- خلا
- ہسپانوی
- خصوصی
- مخصوص
- خاص طور پر
- تفصیلات
- مخصوص
- تیزی
- خرچ
- تقسیم
- الگ ہوجاتا ہے
- کھیل
- چوک میں
- کھڑے ہیں
- اسٹینڈ
- معیار
- شروع کریں
- شروع
- شروع
- حالت
- بیانات
- مستحکم
- مرحلہ
- مراحل
- ابھی تک
- بند کرو
- روکنا
- رک جاتا ہے
- ذخیرہ
- ذخیرہ
- ذخیرہ
- پردہ
- ذخیرہ کرنے
- کہانی
- براہ راست
- سٹریم
- محرومی
- کارگر
- سویوستیت
- طاقت
- ہڑتالیں
- سلک
- ساخت
- منظم
- ڈھانچوں
- ڈھانچہ
- سٹائل
- موضوع
- بعد میں
- کامیابی کے ساتھ
- اس طرح
- سوٹ
- موزوں
- سویٹ
- مختصر
- خلاصہ
- غروب آفتاب
- حمایت
- تائید
- کی حمایت کرتا ہے
- اس بات کا یقین
- پائیداری
- ہم آہنگی
- خلاصہ
- نحو
- کے نظام
- سسٹمز
- ٹیبل
- درزی
- موزوں
- لے لو
- لیتا ہے
- اہداف
- ٹاسک
- کاموں
- ٹیم
- ٹیموں
- بتا
- سانچے
- سانچے
- ٹرمنل
- اصطلاحات۔
- شرائط
- ٹیسٹ
- ٹیسٹنگ
- متن
- سے
- شکریہ
- کہ
- ۔
- مبادیات
- مرکز
- کے بارے میں معلومات
- نیو یارک ٹائمز
- منصوبے
- ماخذ
- دنیا
- ان
- ان
- تو
- وہاں.
- یہ
- وہ
- چیزیں
- اس
- ان
- اگرچہ؟
- کے ذریعے
- بھر میں
- وقت
- وقت لگتا
- اوقات
- عنوان
- کرنے کے لئے
- مل کر
- ٹوکن
- ٹوکن بنانا
- ٹوکن
- بھی
- کے آلے
- ٹول کٹ
- اوزار
- سب سے اوپر
- موضوع
- موضوعات
- کل
- شہر
- سراغ لگانا
- ٹریک
- روایتی
- ٹریننگ
- تبدیل
- تبدیلی
- ٹرانسفارمر
- ٹرانسفارمرز
- منتقلی
- مقدمے کی سماعت
- سچ
- واقعی
- کوشش
- ٹیوننگ
- ٹرن
- ٹرننگ
- سبق
- دوپہر
- دو
- قسم
- اقسام
- ٹائپ اسکرپٹ
- عام طور پر
- ui
- آخر میں
- متاثر نہیں ہوا
- کے تحت
- بنیادی
- سمجھ
- افہام و تفہیم
- سمجھتا ہے۔
- متحد
- منفرد
- متحدہ
- یونیورسل
- برعکس
- جب تک
- اپ ڈیٹ کریں
- تازہ ترین معلومات
- اپ لوڈ کردہ
- URL
- us
- استعمالی
- استعمال
- استعمال کی شرائط
- استعمال کیس
- استعمال کیا جاتا ہے
- رکن کا
- صارف مواجہ
- صارفین
- استعمال
- کا استعمال کرتے ہوئے
- افادیت
- استعمال
- استعمال کیا
- استعمال کرتا ہے
- استعمال کرنا۔
- v1
- توثیق
- قابل اعتبار
- قیمتی
- قیمت
- اقدار
- متغیر
- مختلف اقسام کے
- مختلف
- Ve
- ورسٹائل
- ورژن
- بہت
- کی طرف سے
- ویڈیو
- لنک
- خلاف ورزی
- نظر
- تصور کرنا
- اہم
- vs
- چلنا
- واک تھرو
- چاہتے ہیں
- تھا
- دیکھیئے
- راستہ..
- طریقوں
- we
- موسم
- ویب
- ویب براؤزر
- ویب خدمات
- ویب سائٹ
- اچھا ہے
- اچھی طرح سے جانا جاتا ہے
- تھے
- کیا
- کیا ہے
- کیا
- جب
- چاہے
- جس
- جبکہ
- ڈبلیو
- پوری
- کیوں
- وسیع
- بڑے پیمانے پر
- ویجیٹ
- وکیپیڈیا
- گے
- ونڈو
- جیت
- ساتھ
- کے اندر
- بغیر
- لفظ
- کام
- کام کیا
- کام کا بہاؤ
- کام کے بہاؤ
- کام کر
- کام کرتا ہے
- دنیا
- گا
- لکھنا
- تحریری طور پر
- X
- ابھی
- یارک
- تم
- اور
- اپنے آپ کو
- یو ٹیوب پر
- ZenDesk کے
- زیفیرنیٹ
- زپ