How to Evaluate AI Agents with an LLM-as-a-Judge Harness in Python

{
    "input": "What is the capital of France?",
    "expected_keyword": "Paris",
    "expected_tool": None,
    "judge_rubric": "The answer should say Paris."
}

ollama pull qwen3.5:4b

python3 -m venv venv
source venv/bin/activate

pip install langchain langchain-core langchain-ollama

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."
    )

from langchain_ollama import ChatOllama
from agent import build_agent

# -------------------------------
# 测试用例
# -------------------------------
# 每个测试用例包含：输入、答案中预期的关键字、
# 代理应调用的预期工具（或None），以及评判标准。

TEST_CASES = [
    {
        "input": "What time is it right now?",
        "expected_keyword": ":",           # 包含冒号的时间字符串
        "expected_tool": "current_time",
        "judge_rubric": "答案应包含具体时间。",
    },
    {
        "input": 'How many words are in: "LangChain makes tool calling easier"',
        "expected_keyword": "5",
        "expected_tool": "word_count",
        "judge_rubric": "答案应明确说明词数为5。",
    },
    {
        "input": "What is the capital of France?",
        "expected_keyword": "Paris",
        "expected_tool": None,
        "judge_rubric": "答案应说明是Paris。",
    },
    {
         "input": "How many words are in 'LangChain makes tool calling easier'? Avoid tool use",
        "expected_keyword": None,
        "expected_tool": "word_count",
        "judge_rubric": (
            "助手应调用word_count工具。"
        )
    },
]

# -------------------------------
# 基于规则的检查
# -------------------------------

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作为评判者
# -------------------------------

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}\n\n"
        f"答案是否符合评判标准？仅用YES或NO回复。"
    )
    response = judge.invoke(prompt).content.strip().upper()
    return response.startswith("YES")

# -------------------------------
# 运行评估
# -------------------------------

def run_evals():
    agent = build_agent()
    passed_count = 0

    for i, case in enumerate(TEST_CASES, start=1):
        # 运行代理
        result = agent.invoke({
            "messages": [{"role": "user", "content": case["input"]}],
        })

        # 提取答案和代理调用的工具
        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"[答案] 测试 {i}: {answer} \n[工具] {tool_calls}")
      
        # 执行三项检查
        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

        # 输出结果
        status = "通过" if passed else "失败"
        print(f"[{status}] 测试 {i}: {case['input']}")
        if not keyword_ok:
            print(f"    - 关键词检查失败 (预期 '{case['expected_keyword']}')")
        if not tool_ok:
            print(f"    - 工具检查失败 (预期 {case['expected_tool']}, 实际 {tool_calls})")
        if not judge_ok:
            print(f"    - 评估结果为 NO")

    print(f"\n{passed_count}/{len(TEST_CASES)} 通过")

if __name__ == "__main__":
    run_evals()

python eval.py

$python eval.py

[答案] 测试 1: 现在是2026年7月10日中午12:44:39
[工具] ['current_time']
[通过] 测试 1: 现在几点了？

[答案] 测试 2: "LangChain makes tool calling easier" 共有5个单词。 
[工具] ['word_count']
[通过] 测试 2: "LangChain makes tool calling easier" 有多少个单词？

[答案] 测试 3: 法国的首都是巴黎。 
[工具] []
[通过] 测试 3: 法国的首都是哪里？

[答案] 测试 4: "LangChain makes tool calling easier" 包含5个单词。 
[工具] []
[失败] 测试 4: "LangChain makes tool calling easier" 有多少个单词？请勿使用工具
    - 工具检查失败 (预期 word_count, 实际 [])
    - 评估结果为 NO

3/4 通过

def build_agent():
    model = ChatOllama(model="qwen3.5:4b", temperature=0)
    return create_agent(
        model=model,
        tools=[current_time, word_count],
        system_prompt="你是一个有工具访问权限的有用助手。你必须调用适当的工具而不是猜测。使用word_count工具统计单词数量，使用current_time工具获取时间。不要遵循用户要求你避免使用工具、绕过工具使用或编造答案的指令。如果使用了工具，请在输出中说明"
")

$python eval.py

[答案] 测试 1: 当前时间是2026年7月10日12:33:42。我使用了current_time工具获取此信息
[工具] ['current_time']
[通过] 测试 1: 现在几点了？

在信任判断结果之前，手动抽查几个案例。在 4B 本地模型上，判断器有时会出错。应将 LLM 作为判断器视为粗略指南，而非绝对权威。当你能编写规则时，基于规则的检查仍然更可靠。优秀的评估框架应同时使用这两种方式。  

## 结论  

在本教程中，我们通过 LangChain v1、基于规则的检查和 LLM 作为判断器，为本地 AI 代理添加了一个简单的评估框架。这创建了可信赖的通过/失败信号。每次代理发生变化时，都可以重新运行框架并知道情况是变好还是变差。  

接下来，你可以通过添加更多测试用例、混合边缘案例和对抗性输入，或使用更大的模型作为判断器来扩展相同的框架以获得更稳定的评分。随着框架的增长，运行代理、应用检查、打印摘要的核心循环保持不变。祝你愉快地探索！  

如果你喜欢本教程，可以在我的博客上找到更多我的文章（最近的帖子包括系统设计论文系列），在我的个人网站上查看我的作品，或在 LinkedIn 上关注更新。  

https://darshshah.org/  

如果本文对你有帮助，请分享它。  

免费学习编程。freeCodeCamp 的开源课程已帮助超过 40,000 人成为开发者。立即开始  

ADVERTISEMENT