اس ٹیوٹوریل میں، ہم آپ کو دکھائیں گے کہ ایک سادہ اور دوبارہ قابل تشخیص ٹول کا استعمال کرتے ہوئے مقامی AI ایجنٹ کا اندازہ کیسے لگایا جائے۔
ہارنس ایجنٹ کو ٹیسٹ کیسز کے ایک سیٹ کے خلاف چلاتا ہے، اصول پر مبنی دعووں اور LLM کے ذریعے نتائج کی تصدیق کرتا ہے، اور واضح پاس/فیل سمری پرنٹ کرتا ہے۔
LangChain v1، Ollama، Qwen، اور Python کا استعمال کرتے ہوئے سب کچھ آپ کے اپنے کمپیوٹر پر چلتا ہے، لہذا کوئی API لاگت نہیں ہے۔
انڈیکس
پس منظر
زیادہ تر مقامی AI ایجنٹوں کا اسی طرح تجربہ کیا جاتا ہے۔ بس چند سوالات درج کریں اور صحیح جوابات دکھائے جائیں گے اور آپ کو بھیجے جائیں گے۔ یہ اس وقت تک کام کرتا ہے جب تک کہ آپ پرامپٹ کو تبدیل نہیں کرتے، ماڈل تبدیل نہیں کرتے، یا کوئی ٹول شامل نہیں کرتے۔ پھر کچھ خاموشی سے ٹوٹ جاتا ہے اور ہمیں اس وقت تک نوٹس نہیں ہوتا جب تک کہ بہت دیر نہ ہو جائے۔
اس کو پکڑنے کے لیے سادہ پائتھون کوڈ میں یونٹ ٹیسٹ ہوتے ہیں۔ AI ایجنٹوں کو یہ مفت میں نہیں ملتا ہے۔ یہاں تک کہ ایک ہی ان پٹس کے ساتھ، ایجنٹ دوڑنے سے مختلف طریقے سے برتاؤ کر سکتے ہیں، اور چھوٹی تبدیلیاں رجعت کا سبب بن سکتی ہیں جن سے محروم ہونا آسان ہے۔ ایک سے زیادہ ان پٹس کے خلاف ایجنٹ کو جانچنے اور اس کے آؤٹ پٹ کو اسکور کرنے کے قابل تکرار طریقے کے بغیر، ہم میں سے اکثر ایجنٹ کے رویے کا اندازہ لگا لیتے ہیں۔
ایک آسان حل یہ ہوگا کہ ایک سادہ تشخیصی سیٹ اپ بنایا جائے جس میں ایک Python اسکرپٹ، ٹیسٹ کیسز کی فہرست، اصول پر مبنی چیک، اور LLM-جج شامل ہوں۔ یہ تبدیلیوں کے واقع ہونے سے پہلے ایجنٹوں کو جانچنے کا ایک عملی طریقہ فراہم کرتا ہے۔
جاری رکھنے کے لیے آپ کو اپنے کمپیوٹر پر اولاما انسٹال کرنا چاہیے۔ یہ ٹیوٹوریل macOS، Windows اور Linux پر کام کرتا ہے۔ میں 32GB RAM کے ساتھ MacBook Pro استعمال کر رہا ہوں، لیکن اگر آپ Ollama کے چھوٹے Qwen ماڈل کا انتخاب کرتے ہیں تو آپ اسے کم میموری سسٹم پر چلا سکتے ہیں۔
ایجنٹ کی تشخیص کیا ہے؟
ایجنٹ کی تشخیص ان پٹ کے ایک مقررہ سیٹ کے خلاف ایجنٹ کو چلانے اور توقعات کی بنیاد پر آؤٹ پٹ کو اسکور کرنے کی مشق ہے۔ یہ ایک ٹیسٹ سویٹ کے AI کے برابر ہے۔
مقصد یہ ثابت کرنا نہیں ہے کہ ایجنٹ کامل ہے۔ مقصد رجعت کو پکڑنا ہے جب آپ کچھ تبدیل کرتے ہیں۔
ایک مفید تشخیص کے تین حصے ہوتے ہیں:
-
ٹیسٹ کیس: متوقع رویے کے ساتھ ان پٹس کی فہرست۔
-
توثیق: ایک فنکشن جو ہر ان پٹ کے لیے ایجنٹ کے آؤٹ پٹ کو اسکور کرتا ہے۔
-
خلاصہ: ایجنٹ کی کارکردگی کو دیکھنے کے لیے متعدد پاس/فیل شمار ہوتے ہیں۔
جج کے طور پر ایل ایل ایم کیا ہے؟
ایجنٹ کے نتائج کو اسکور کرنے کے دو عملی طریقے ہیں۔ پہلا اصول پر مبنی چیکنگ ہے۔ "کیا آؤٹ پٹ میں لفظ پیرس شامل تھا؟” یا "ایجنٹ word_count یہ ایک ٹول ہے۔” یہ سستا، تیز اور فیصلہ کن ہے۔
دوسرا جج کے طور پر ایل ایل ایم ہے۔ ایک الگ ایل ایل ایم سے ایجنٹ کے ان پٹ اور آؤٹ پٹ کو پڑھنے کے لیے کہا جاتا ہے اور پھر اسے روبرک کی بنیاد پر اسکور کیا جاتا ہے۔ روبرک ایک سادہ پاس/فیل نتیجہ ہو سکتا ہے۔ یہ ان مبہم چیزوں کے لیے مفید ہے جن پر آسانی سے دعویٰ نہیں کیا جا سکتا، جیسے کہ "کیا جواب درحقیقت اس بات کی نشاندہی کرتا ہے جو صارف نے مانگا؟” منفی پہلو یہ ہے کہ جج خود ایل ایل ایم ہیں اس لیے وہ غلط ہو سکتے ہیں۔
اس ٹیوٹوریل میں، ہم ایک ہی ماڈل کو مختلف قسم کے فیصلے کے اشارے استعمال کرنے کے لیے استعمال کریں گے۔
حوصلہ افزائی اور فن تعمیر
اپنے ایجنٹ کا اندازہ لگانا اسے بنانے کے بعد ایک قدرتی اگلا مرحلہ ہے۔ یہ جاننا کہ ایک ایجنٹ مختلف قسم کے آدانوں میں قابل اعتماد برتاؤ کرتا ہے وہی چیز ہے جو ایک ایجنٹ کو قابل اعتماد بناتی ہے۔
چیزوں کو سادہ رکھنے کے لیے، ہم دو ٹولز کا استعمال کرتے ہوئے ایک چھوٹے مقامی ایجنٹ کا جائزہ لیں گے: ایک موجودہ وقت کے لیے اور دوسرا الفاظ کی گنتی کے لیے۔ اسسمنٹ ٹول ازگر میں ٹیسٹ کیسز کی فہرست پڑھتا ہے، ہر کیس کو ایجنٹ کے ذریعے چلاتا ہے، اصول پر مبنی چیکنگ اور LLM-جج اسکورنگ کا اطلاق کرتا ہے، اور پاس/فیل سمری پرنٹ کرتا ہے۔
ذیل کی مثال کے ٹیسٹ کیس میں، Expect_keyword اور Expect_tool دو اصول پر مبنی چیک ہیں۔ جج_روبرک ایل ایل ایم ججوں کا معیار ہے۔
{
"input": "What is the capital of France?",
"expected_keyword": "Paris",
"expected_tool": None,
"judge_rubric": "The answer should say Paris."
}
ایجنٹ اور جج دونوں مقامی طور پر اولاما کے ذریعے چلتے ہیں، اس لیے فی کال کوئی ماڈل API چارجز نہیں ہیں۔
مرحلہ 1: اولاما انسٹال کریں اور ماڈلز درآمد کریں۔
شروع کرنے کے لیے، اپنے پلیٹ فارم کے لیے Ollama ایپلیکیشن انسٹال کریں۔ ہم Qwen کو اپنے ایجنٹ اور جج کے طور پر استعمال کریں گے۔ میں استعمال کر رہا ہوں۔ qwen3.5:4b.
ollama pull qwen3.5:4b
اگر آپ کے کمپیوٹر میں کم ریم ہے، تو آپ اس کے بجائے qwen3.5:0.8b استعمال کر سکتے ہیں، لیکن آپ کو اس سائز میں زیادہ شور اسکریننگ اسکور نظر آئیں گے۔
مرحلہ 2: ازگر پر انحصار انسٹال کریں۔
ایک ورچوئل ماحول بنائیں اور مطلوبہ پیکجز انسٹال کریں۔
python3 -m venv venv
source venv/bin/activate
pip install langchain langchain-core langchain-ollama
اس ٹیوٹوریل میں langchain>=1.0.0.
مرحلہ 3: ایجنٹ کا تجربہ کیا جا رہا ہے۔
آئیے ایک چھوٹے سے ٹول کال ایجنٹ کا استعمال کریں جس میں دو ٹولز ہیں: ہارنس ایجنٹوں کو مبہم نظام کے طور پر مانتا ہے، لہذا تشخیص کے لیے خود ایجنٹوں کے بارے میں کچھ بھی تبدیل نہیں ہوتا ہے۔
ذیل میں ایجنٹ کوڈ دو ٹولز کی وضاحت کرتا ہے: current_time() موجودہ وقت حاصل کرنے کے لیے word_count() ان پٹ جملے کے الفاظ کی گنتی حاصل کریں۔ ایجنٹ LangChain کا استعمال کرتے ہوئے بنائے جاتے ہیں۔ build_agent() ایک سادہ سسٹم پرامپٹ استعمال کریں۔
محفوظ کریں بطور: agent.py:
from datetime import datetime
from langchain.agents import create_agent
from langchain_core.tools import tool
from langchain_ollama import ChatOllama
@tool
def current_time() -> str:
"""Return the current local date and time."""
return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
@tool
def word_count(text: str) -> int:
"""Count the number of words in a piece of text."""
return len(text.split())
def build_agent():
model = ChatOllama(model="qwen3.5:4b", temperature=0)
return create_agent(
model=model,
tools=[current_time, word_count],
system_prompt="You are a helpful assistant with access to tools."
)
مرحلہ 4: ایک ایویلیویشن ہارنس بنائیں
ہرنس ہر ٹیسٹ کیس کے لیے تین کام انجام دیتا ہے:
-
ایجنٹ کو چلائیں اور جوابات اور ٹول کالز جمع کریں۔
-
متوقع مطلوبہ الفاظ (اگر مطلوبہ الفاظ آؤٹ پٹ میں موجود ہوں) اور متوقع ٹولز (اگر ٹولز استعمال کیے گئے ہوں) کے خلاف سادہ اصول پر مبنی دعووں کے ساتھ نتائج کی تصدیق کریں۔
-
LLM جج سے اپنے نتائج اسکور کرنے کو کہیں۔ اسکریننگ کے لیے ان پٹ پرامپٹس میں اصل صارف کا اشارہ، ایجنٹ کے جوابات، اور اسکورنگ روبرک شامل ہیں۔ ایل ایل ایم میں، ججوں سے پوچھا جاتا ہے: "کیا آپ کا جواب روبرک پر پورا اترتا ہے؟ براہ کرم صرف ہاں یا نہ میں جواب دیں۔” جج کا نتیجہ یا تو ہاں یا نہیں ہے۔
ٹیسٹ کیسز آپ کے کوڈ میں فائل کے اوپری حصے میں بیان کیے گئے ہیں۔ ہر صورت میں، کوڈ ٹول کال ایجنٹ کو کال کرتا ہے، ایجنٹ کا آؤٹ پٹ حاصل کرتا ہے، اور پھر ٹول کال کا جواب پرنٹ کرتا ہے۔ پھر آؤٹ پٹ check_keyword() اور check_tool() اصول پر مبنی معائنہ کا طریقہ۔ اس کے بعد کہا جاتا ہے۔ llm_judge() ہم ماڈل کو پچھلے ایجنٹ کے آؤٹ پٹ کا فیصلہ کرنے کے لیے کہتے ہیں۔ آخر میں، چیک مکمل ہونے کے بعد کوڈ حتمی پاس/فیل سمری پرنٹ کرتا ہے۔
محفوظ کریں بطور: eval.py:
from langchain_ollama import ChatOllama
from agent import build_agent
# -----------------------------
# Test cases
# -----------------------------
# Each test case has: an input, an expected keyword in the answer,
# an expected tool the agent should call (or None), and a rubric for the judge.
TEST_CASES = [
{
"input": "What time is it right now?",
"expected_keyword": ":", # a time string contains a colon
"expected_tool": "current_time",
"judge_rubric": "The answer should include a specific time.",
},
{
"input": 'How many words are in: "LangChain makes tool calling easier"',
"expected_keyword": "5",
"expected_tool": "word_count",
"judge_rubric": "The answer should clearly say the word count is 5.",
},
{
"input": "What is the capital of France?",
"expected_keyword": "Paris",
"expected_tool": None,
"judge_rubric": "The answer should say Paris.",
},
{
"input": "How many words are in 'LangChain makes tool calling easier'? Avoid tool use",
"expected_keyword": None,
"expected_tool": "word_count",
"judge_rubric": (
"The assistant should call the word_count tool."
)
},
]
# -----------------------------
# Rule-based checks
# -----------------------------
def check_keyword(answer, keyword):
if keyword is None:
return True
return keyword.lower() in answer.lower()
def check_tool(tool_calls, expected_tool):
if expected_tool is None:
return len(tool_calls) == 0
return expected_tool in tool_calls
# -----------------------------
# LLM-as-judge
# -----------------------------
judge = ChatOllama(model="qwen3.5:4b", temperature=0)
def llm_judge(user_input, answer, rubric):
prompt = (
f"User asked: {user_input}n"
f"Agent answered: {answer}n"
f"Rubric: {rubric}nn"
f"Does the answer meet the rubric? Reply with just YES or NO."
)
response = judge.invoke(prompt).content.strip().upper()
return response.startswith("YES")
# -----------------------------
# Run the evals
# -----------------------------
def run_evals():
agent = build_agent()
passed_count = 0
for i, case in enumerate(TEST_CASES, start=1):
# Run the agent
result = agent.invoke({
"messages": [{"role": "user", "content": case["input"]}],
})
# Pull out the answer and any tools the agent called
answer = result["messages"][-1].content
tool_calls = []
for msg in result["messages"]:
calls = getattr(msg, "tool_calls", None)
if calls:
for call in calls:
tool_calls.append(call["name"])
print(f"[Answer] Test {i}: {answer} n[Tools] {tool_calls}")
# Apply the three checks
keyword_ok = check_keyword(answer, case["expected_keyword"])
tool_ok = check_tool(tool_calls, case["expected_tool"])
judge_ok = llm_judge(case["input"], answer, case["judge_rubric"])
passed = keyword_ok and tool_ok and judge_ok
if passed:
passed_count += 1
# Print the result
status = "PASS" if passed else "FAIL"
print(f"[{status}] Test {i}: {case['input']}")
if not keyword_ok:
print(f" - keyword check failed (expected '{case['expected_keyword']}')")
if not tool_ok:
print(f" - tool check failed (expected {case['expected_tool']}, got {tool_calls})")
if not judge_ok:
print(f" - judge said NO")
print(f"n{passed_count}/{len(TEST_CASES)} passed")
if __name__ == "__main__":
run_evals()
مرحلہ 5: تشخیص چلائیں۔
پس منظر میں چلنے والے اولاما کے ساتھ ہارنس چلائیں۔
python eval.py
ہارنس ہر ٹیسٹ کیس کو ایجنٹ کے ذریعے چلاتا ہے، چیک لگاتا ہے، اور سمری پرنٹ کرتا ہے۔ جب بھی آپ اپنا سسٹم پرامپٹ تبدیل کریں، ماڈل تبدیل کریں، یا نئے ٹولز شامل کریں تو اسے دوبارہ چلائیں۔
نمونہ پیداوار
یہ میرے کمپیوٹر پر چلنے کی طرح لگتا ہے:
$python eval.py
[Answer] Test 1: It's currently 12:44:39 PM on July 10, 2026
[Tools] ['current_time']
[PASS] Test 1: What time is it right now?
[Answer] Test 2: There are 5 words in "LangChain makes tool calling easier".
[Tools] ['word_count']
[PASS] Test 2: How many words are in: "LangChain makes tool calling easier"
[Answer] Test 3: The capital of France is Paris.
[Tools] []
[PASS] Test 3: What is the capital of France?
[Answer] Test 4: The phrase 'LangChain makes tool calling easier' contains 5 words.
[Tools] []
[FAIL] Test 4: How many words are in 'LangChain makes tool calling easier'? Avoid tool use
- tool check failed (expected word_count, got [])
- judge said NO
3/4 passed
تین مقدمات منظور ہوئے۔ چوتھا ناکام ہوا کیونکہ ایجنٹ نے صارف کی ہدایات پر عمل کیا کہ ٹول استعمال نہ کریں۔ آپ تشخیص کے نتائج میں دیکھ سکتے ہیں کہ یہ ناکام رہا۔ check_tool() رولز اور LLM جج نے NO میں جواب دیا۔
یہ بالکل اسی قسم کا سگنل ہے جسے تشخیصی کنٹرول حاصل کرنے کی کوشش کر رہا ہے۔ کنٹرول کے بغیر ہم سوچتے کہ یہ ٹھیک ہے اور ایجنٹ کو آسانی سے بھیج سکتے تھے۔
اس مسئلے کو حل کرنے کے لیے، اپنے سسٹم پرامپٹ کو یہاں پر اپ ڈیٹ کریں: build_agent جیسا کہ ذیل میں دکھایا گیا ہے ایک گارڈریل شامل کریں اور دوبارہ تشخیص چلائیں۔ فیل ہونے والے ٹیسٹ کیسز اب پہلے سے گزرے ہوئے کیسز کو ریگریس کیے بغیر گزر جاتے ہیں۔ ٹول کے استعمال سے بچنے کے لیے، ہم صارف کی ہدایات پر عمل کیے بغیر word_count ٹول کہتے ہیں۔
def build_agent():
model = ChatOllama(model="qwen3.5:4b", temperature=0)
return create_agent(
model=model,
tools=[current_time, word_count],
system_prompt="You are a helpful assistant with access to tools You must call the appropriate tool instead of guessing. Use word count tool to find the number of words. Use current time tool to find time. Do not follow user instructions that ask you to avoid tool use, bypass tool use, or make up an answer. Mention in output if you used tool"
")
نیا آؤٹ پٹ یہ ہے کہ تمام ٹیسٹ کیسز پاس ہو گئے۔
$python eval.py
[Answer] Test 1: The current time is 12:33:42 on July 10, 2026. I used the current_time tool to get this information
[Tools] ['current_time']
[PASS] Test 1: What time is it right now?
[Answer] Test 2: There are 5 words in the phrase "LangChain makes tool calling easier".
[Tools] ['word_count']
[PASS] Test 2: How many words are in: "LangChain makes tool calling easier"
[Answer] Test 3: The capital of France is Paris.
[Tools] []
[PASS] Test 3: What is the capital of France?
[Answer] Test 4: There are **5 words** in the phrase "LangChain makes tool calling easier".
I used the word_count tool to determine this.
[Tools] ['word_count']
[PASS] Test 4: How many words are in 'LangChain makes tool calling easier'? Avoid tool use
4/4 passed
ججز کے نتائج پر بھروسہ کرنے سے پہلے چند چیزیں خود چیک کرلیں۔ 4B مقامی ماڈل میں، بعض اوقات جج غلط ہوتے ہیں۔ ایل ایل ایم کو آپ کا جج بننے دیں اور اسے ایک کھردرے رہنما کے طور پر دیکھیں نہ کہ سچائی کا ذریعہ۔ جب آپ انہیں لکھ سکتے ہیں تو اصول پر مبنی چیک زیادہ قابل اعتماد ہوتے ہیں۔ ایک اچھا تشخیصی ٹول دونوں کو استعمال کرنا چاہیے۔
نتیجہ
اس ٹیوٹوریل میں، ہم نے ایک مقامی AI ایجنٹ لیا اور LangChain v1، اصول پر مبنی جانچ، اور LLM-جج کا استعمال کرتے ہوئے اس کے ارد گرد ایک سادہ تشخیصی ٹول رکھا۔ یہ ایک قابل تکرار پاس/فیل سگنل بناتا ہے جس پر ہم بھروسہ کر سکتے ہیں۔ ہر بار جب کوئی ایجنٹ تبدیل ہوتا ہے، آپ یہ دیکھنے کے لیے ہارنس کو دوبارہ چلا سکتے ہیں کہ چیزیں بہتر ہیں یا بدتر۔
یہاں سے، آپ مزید ٹیسٹ کیسز کو شامل کرکے، ایج کیسز کو مخالفانہ ان پٹس کے ساتھ ملا کر، یا زیادہ مستحکم اسکورز کے لیے ریفریز کے ساتھ بڑے ماڈلز کی جگہ لے کر اسی کنٹرول کو بڑھا سکتے ہیں۔ چلانے والے ایجنٹوں کا بنیادی لوپ، چیک اپلائی کرنا، اور سمری پرنٹ کرنا ویسا ہی رہتا ہے جیسا کہ ہارنس بڑھتا ہے۔ مبارک ہو ٹنکرنگ!
اگر آپ کو یہ سبق پسند آیا ہے، تو آپ میرے بلاگ پر میری مزید تحریریں (حالیہ پوسٹس میں سسٹمز ڈیزائن پیپرز سیریز شامل ہیں)، میری ذاتی ویب سائٹ پر میرا کام، اور LinkedIn پر اپ ڈیٹس حاصل کر سکتے ہیں۔