LLM Evaluation Tools

LLM applications are frustratingly difficult to test due to their probabilistic nature. However, testing is crucial for customer-facing applications to ensure the reliability of generated answers. So, how does one effectively test an LLM app? Enter Confident AI's DeepEval: a comprehensive open-source LLM evaluation framework with excellent developer experience. Key features of DeepEval: - Ease of use: Very similar to writing unit tests with pytest. - Comprehensive suite of metrics: 14+ research-backed metrics for relevancy, hallucination, etc., including label-less standard metrics, which can quantify your bot's performance even without labeled ground truth! All you need is input and output from the bot. See the list of metrics and required data in the image below! - Custom Metrics: Tailor your evaluation process by defining your custom metrics as your business requires. - Synthetic data generator: Create an evaluation dataset synthetically to bootstrap your tests My recommendations for LLM evaluation: - Use OpenAI GPT4 as the metric model as much as possible. - Test Dataset Generation: Use the DeepEval Synthesizer to generate a comprehensive set of realistic questions! Bulk Evaluation: If you are running multiple metrics on multiple questions, generate the responses once, store them in a pandas data frame, and calculate all the metrics in bulk with parallelization. - Quantify hallucination: I love the faithfulness metric, which indicates how much of the generated output is factually consistent with the context provided by the retriever in RAG! CI/CD: Run these tests automatically in your CI/CD pipeline to ensure every code change and prompt change doesn't break anything. - Guardrails: Some high-speed tests can be run on every API call in a post-processor before responding to the user. Leave the slower tests for CI/CD. 🌟 DeepEval GitHub: https://lnkd.in/g9VzqPqZ 🔗 DeepEval Bulk evaluation: https://lnkd.in/g8DQ9JAh Let me know in the comments if you have other ways to test LLM output systematically! Follow me for more tips on building successful ML and LLM products! Medium: https://lnkd.in/g2jAJn5 X: https://lnkd.in/g_JbKEkM #generativeai #llm #nlp #artificialintelligence #mlops #llmops

Knowledge Graphs as Powerful Evaluation Tools for LLM Document Intelligence 📃 Organizations across industries are grappling with an unprecedented deluge of unstructured information contained in documents. From medical records and legal contracts to financial reports and technical manuals, these text-heavy resources hold valuable insights that, if properly harnessed, could revolutionize decision-making processes and operational efficiencies. Document intelligence powered by LLMs represents a paradigm shift in how we approach unstructured data. These sophisticated AI models, trained on vast corpora of text, demonstrate remarkable abilities in understanding context, extracting relevant information, and even generating human-like responses. Unlike traditional rule-based systems or narrow AI models, LLMs offer unparalleled versatility in tackling diverse document processing tasks. They can adapt to new domains with minimal fine-tuning, understand complex relationships within text, and provide insights that were previously accessible only through human expertise. The applications of LLM-driven document intelligence are vast and transformative. In healthcare, these models can analyze medical records to assist in diagnosis and treatment planning. In the legal sector, they can review contracts to identify potential risks or inconsistencies. The potential for increased efficiency, accuracy, and novel insights across industries is immense. However, as we venture into this new frontier of AI-powered document processing, a critical question emerges : How do we effectively evaluate the performance of these sophisticated language models? This is where the importance of robust evaluation methodologies comes into sharp focus. Evaluation is not merely an academic exercise; it is the cornerstone of responsible AI deployment in real-world scenarios. Traditional evaluation metrics for natural language processing tasks, such as BLEU or ROUGE scores, fall short when assessing the complex, multi-faceted nature of document intelligence. This is where Knowledge Graphs (KGs) emerge as a powerful and innovative evaluation tool. Knowledge graphs offer a structured representation of information, capturing entities, relationships, and complex hierarchies within documents. By leveraging KGs in the evaluation process, we can assess LLMs’ performance in a way that aligns more closely with human-like understanding of document content. KG evaluation tools by Zhang et al. 2024, offer a sophisticated approach to assessing document intelligence, especially for radiology reports : ReXKG-NSC measures entity capture. It compares nodes in AI-generated and human-written report graphs. ReXKG-AMS evaluates relationship accuracy. It compares edge structures between graphs. ReXKG-SCS assesses complex concept representation. It examines important subgraphs within the larger structure.

Nicolas Yax just turned LLMs into DNA samples. 🧬 And discovered how to trace their family trees. PhyloLM applies genetic analysis to language models, revealing hidden relationships even in closed-source models where training details are secret. The framework is brilliantly simple: ▪️ LLMs = populations ▪️ Prompts = genes ▪️ Generated tokens = alleles By calculating genetic distances between model outputs, PhyloLM creates evolutionary trees showing which models share "ancestry." 🔍 What They Found: Using only generated tokens, they proved NeuralHermes was based on OpenHermes. No access to weights. No training logs. Just outputs. Think about that for a second. 📊 Why This Matters: 1️⃣ Model Attribution: Finally, a way to detect when someone fine-tuned your model without credit 2️⃣ Architecture Detective: Reveals shared training data or methods between models 3️⃣ Closed-Source Analysis: Works even when companies hide their model details 🧪 The Method: • Feed identical prompts to different models • Analyze token generation patterns • Calculate "genetic distance" between outputs • Build phylogenetic trees showing relationships This is a forensic tool for the AI age. When everyone's building on everyone else's work, PhyloLM shows the real family tree. Nicolas released everything, find the links in the comments 👇

We spent months evaluating our AI data analyst at Wobby. Here are 4 lessons we wish we knew earlier… 1. Use deterministic checks wherever you can—LLM scoring should be the last resort. LLMs are non-deterministic by nature. Run the same evaluation twice and you’ll get two different results. Wherever possible, we now rely on hard checks: How many hard errors occured? Is the amount of created charts what we expected? These are clear pass/fail signals. We only bring in LLMs for tests that are harder to automate—like judging if the structure of a summary makes sense. 2. Single LLM judges introduce bias—use a jury instead. We noticed that when a single LLM (eg GPT-4o) acts as the judge, results can get biased. Prompt it as an “expert”, and it becomes overly critical… Plus, LLMs sometimes “recognize” their own style in the answer, leading to weirdly inconsistent feedback. What worked better? Using a jury of different models and averaging their scores. It reduced bias and gave us more stable evaluations. (We want to start looking into Root Signals) 3. Avoid vague scoring scales—force the LLM as a judge into clear categories. Asking an LLM to “score from 1 to 5” sounds simple, but it’s surprisingly unreliable. LLMs struggle with keeping a consistent scale. Instead, we switched to clear, categorical outputs like: • MISSING_CRITICAL_SQL_CONCEPT • PARTIAL_ANSWER • NO_REMARKS Forcing the model to reason why something is wrong gave us much better, more useful feedback. 4. Too many evaluation metrics? You’ll drown. Focus on what matters most. Early on, we tried to evaluate everything—SQL matching, tool usage, summary format, … The reality? Every new metric adds overhead. You need time and resources to refine, test, and review each one. —— If you’re building AI agents, I hope this helps. These lessons took us time (and mistakes) to learn. And… we’re hiring a Software Engineer (Applied AI) to help us build this next-gen AI data analyst. Reach out if you’re interested :) (Quinten & Quinten staring at my screen as i show them my newest prompt for cursor)

You’re in an ML Engineer interview at Perplexity, and the interviewer asks: “Your LLM generates millions of responses daily. How do you evaluate quality without manual review?” Here’s how you answer: LLM evaluation at scale is fundamentally broken. Traditional metrics like BLEU and ROUGE were built for translation tasks—not open-ended generation. Meanwhile, human evaluation costs $50+ per review and takes days to complete what should happen in real time. Production systems need instant feedback on response quality. You can’t wait 48 hours for human reviewers to catch hallucinations or bias issues. The solution: "LLM as a Judge" Use one LLM to evaluate another’s outputs. GPT-4-class judges align with human reviewers ~85% of the time. That’s better than humans agree with each other (~81%). How automated judging works: → Single-output scoring Judge rates one response on criteria like relevance, accuracy, and helpfulness. → Reference-based evaluation Compare outputs against known correct answers. → Pairwise comparison Pick the better response between two options. Each method serves different production needs. --- Quick aside: If you want bites like this daily, subscribe to my newsletter: https://lnkd.in/gCPD6fUz Now, back to the thread. --- Modern judge systems use Chain-of-Thought prompting: 1. Judge explains reasoning step-by-step 2. Applies explicit evaluation criteria 3. Outputs a numerical score with justification 4. Handles edge cases via few-shot examples This reduces arbitrary scoring and improves consistency. Success depends on human-alignment rate - how often the judge agrees with expert reviewers. State-of-the-art systems achieve: - 85% alignment on factual correctness - 78% on creative writing quality - 92% on format compliance These metrics should be tracked religiously in production. For real-world usage, I’d implement: - G-Eval for custom criteria - Pairwise judges for A/B testing - DAG-based decision trees for complex evaluations - Position swapping to eliminate bias - Multi-judge consensus for critical decisions Judges aren’t perfect. Common failure modes include: - Position bias (preferring the first option) - Verbosity bias (favoring longer answers) - Self-preference (rating their own model higher) - Temperature sensitivity These can be mitigated with better prompting and validation checks. A follow-up question that makes you stand out: “How do you handle non-deterministic scoring?” Wrong: “Set temperature = 0.” Right: “Use consensus mechanisms, track score distributions, apply probability weighting for continuous scores, and validate against human baselines.” #machinelearning #datascience #genai #ai #gpt #llm #aiagents #inference #rag

LLMs crush consumer benchmarks but fail at real enterprise tasks. New research exposes why: hidden workflows. Here's the problem. Enterprise systems are webs of interconnected processes where one action triggers cascading effects across multiple systems. Current benchmarks test surface-level task completion, ignoring the chaos underneath. Researchers now introduced "World of Workflows," a benchmark that finally tests what matters in enterprise AI: limited observability, massive database states, and hidden workflow side effects. Think of it like this: consumer benchmarks test if an AI can book a flight. This benchmark tests if an AI understands that canceling a purchase order automatically triggers inventory adjustments, supplier notifications, and accounting entries - all invisible unless you know where to look. Their key findings are the following: 1. Even frontier LLMs struggle with multi-step enterprise workflows 2. Models fail to predict cascading effects across connected systems 3. Performance drops significantly when workflows have hidden dependencies Sounds like your enterprise systems? If models can't reason about how systems actually work - not just execute isolated tasks - deployments will break in expensive ways. Before trusting an LLM with your ERP, ask: does it understand your workflows, or just your interfaces? ↓ 𝐖𝐚𝐧𝐭 𝐭𝐨 𝐤𝐞𝐞𝐩 𝐮𝐩? Join my newsletter with 50k+ readers and be the first to learn about the latest AI research: llmwatch.com 💡

Spent real time this week inside an eval framework most teams evaluating LLMs still don't know exists. DeepEval, from Jeffrey Ip's team at Confident AI. Not a wrapper around a benchmark. An actual testing framework built for how LLM outputs actually fail in production. Here's what it does out of the box: - Hallucination detection - Answer relevancy - Faithfulness, for RAG pipelines specifically - Contextual precision and recall The part most teams skip past: - Custom metrics using LLM-as-judge - Plain-English criteria you define yourself, scored with reasoning attached - Built to run inside CI/CD, the same way you'd run pytest The thing that stands out most: Most eval frameworks assume "correct" is a fixed string you can match against. Real LLM output almost never works that way. DeepEval's answer is a metric you write yourself, scored by another model against your actual criteria, not a hardcoded comparison. That's the actual gap between eyeballing outputs and having a real test suite. Hat tip to Jeffrey Ip and the Confident AI (YC W25) team for building this. One of the more genuinely useful tools in the LLM tooling space right now, and it's not getting the attention it deserves. Repo link in the comments, worth bookmarking. What are you using to test your LLM outputs right now, or is it still eyeballing? #AIEngineering #LLMOps #Evals

GenAI Interview Question Series Interviewer: Your enterprise chatbot gives different answers to the same query across channels. How do you ensure response consistency? Explanation: When an enterprise chatbot gives different answers to the same query across channels (web, mobile, Slack, WhatsApp), it usually indicates inconsistencies in prompts, context handling, retrieval, or model configuration. I address this at multiple layers. 1. Centralize the Core Logic I ensure all channels call a single backend orchestration layer. The same model version, system prompt, temperature, and decoding parameters are enforced centrally, rather than being configured separately per channel. 2. Standardize Prompts and Policies I use versioned system prompts and shared prompt templates. Any business rules, tone, or safety instructions live in the system prompt, not in channel-specific code. Changes go through prompt versioning and A/B validation. 3. Normalize Input and Context Different channels often add metadata or truncate messages differently. I implement a canonical input format so that user queries, conversation history, and user metadata are normalized before reaching the LLM. 4. Align Retrieval (If RAG Is Used) For RAG-based bots, I ensure: Same embedding model and vector store Same top-k, similarity threshold, and re-ranking logic Deterministic retrieval where possible This avoids different documents being surfaced per channel. 5. Control Randomness I keep low temperature and stable top-p/top-k settings for enterprise use cases. For critical intents, I may enable deterministic decoding or response caching. 6. Monitoring and Regression Testing Finally, I run cross-channel consistency tests using golden questions and track semantic similarity of responses. Any drift triggers alerts and prompt/model rollback. #llm #Genai #AI #interview

𝐎𝐩𝐞𝐧-𝐬𝐨𝐮𝐫𝐜𝐞𝐝: 𝐑𝐮𝐯𝐫𝐢𝐜𝐬 - 𝐚𝐧 𝐎𝐒𝐒 𝐠𝐮𝐚𝐫𝐝𝐫𝐚𝐢𝐥 𝐭𝐨 𝐝𝐞𝐭𝐞𝐜𝐭 𝐬𝐢𝐥𝐞𝐧𝐭 𝐛𝐞𝐡𝐚𝐯𝐢𝐨𝐫 𝐝𝐫𝐢𝐟𝐭 𝐢𝐧 𝐋𝐋𝐌 𝐬𝐲𝐬𝐭𝐞𝐦𝐬. One thing I've consistently seen while building LLM-based systems is that problems rarely show up as failures. - Nothing crashes. - No exceptions are thrown. - The system just starts making slightly different decisions over time. In practice, a few patterns keep repeating: - We try a prompt a couple of times, maybe even set temperature to 0, see consistent outputs - and assume it will behave the same once shipped. - A small change (prompt tweak, model upgrade, tool or context change) doesn't break anything, but behavior quietly drifts. - Switching models is easy, but understanding which one behaves more consistently for a given workflow is not. To explore this problem, I built and open-sourced Ruvrics. Ruvrics runs the same input multiple times to establish a behavioral baseline, and helps detect unexpected drift when something changes. It's not a correctness or hallucination checker. It is a lightweight guardrail for places where consistency matters: structured outputs, tool routing, and automation boundaries. (Screenshot below: a support-agent workflow with tool calls run across multiple iterations. Importantly, Ruvrics is intentionally quiet when systems are stable. Seeing “SAFE” is the expected outcome for modern models - the value shows up when behavior changes after prompts, tools, or context evolve. Repo: https://lnkd.in/dD5hd2gs Sharing this openly in case it’s useful to others building or operating LLM systems. Feedback and real-world edge cases are very welcome. #opensource #llm #engineering #developerexperience #aiinfrastructure #ashutosh_ai #opensourcecontribution

I built a small tool that I keep wishing existed whenever I’m comparing LLMs 𝗟𝗟𝗠 𝗖𝗼𝗺𝗽𝗮𝗿𝗮𝘁𝗼𝗿 https://lnkd.in/gceGkJFu 𝗪𝗵𝘆 𝗶𝘁’𝘀 𝘂𝘀𝗲𝗳𝘂𝗹 Comparing models is harder than it should be. You end up running the same prompt across different tools, losing history, and struggling to make a clean side-by-side assessment of output quality, latency, and token usage. This tool lets you run the same prompt set across multiple models and compare results in one place. Importantly it lets you take a conversation from one LLM and continue it in another LLM. This is useful in cases where you want to use a powerful LLM for the initial prompt but don't necessarily need it for subsequent refinements. 𝗞𝗲𝘆 𝗳𝗲𝗮𝘁𝘂𝗿𝗲𝘀  • Side-by-side comparisons across multiple LLMs/providers  • Tracks latency + token usage  • Save/load sessions as JSON  • Share sessions via GitHub Gists 𝗣𝗿𝗼𝘃𝗶𝗱𝗲𝗿𝘀 𝘀𝘂𝗽𝗽𝗼𝗿𝘁𝗲𝗱  • OpenAI  • Anthropic Claude  • Google Gemini  • OpenRouter  • Local Models (Ollama or any compatible endpoint) 𝗣𝗿𝗶𝘃𝗮𝗰𝘆 𝗯𝘆 𝗱𝗲𝗳𝗮𝘂𝗹𝘁 There’s no backend storing your prompts or API keys. Everything is stored locally in your browser (using local storage), and calls are made directly from your browser to the model provider. 𝗦𝗵𝗮𝗿𝗶𝗻𝗴 𝘀𝗲𝘀𝘀𝗶𝗼𝗻𝘀 Your most recent session is saved locally in your browser, and you can export it as a JSON file (and re-import it later to pick up where you left off). If you want to share a comparison, you can also publish the session as a GitHub Gist (public or secret) using a GitHub token, then send a link that will load the exact same session for someone else. Here's an example based on the Claude Career Coach prompt: 𝗢𝗽𝗲𝗻 𝗦𝗼𝘂𝗿𝗰𝗲 This is all a single HTML page with Javascript embedded in it. Download it and deploy it where ever you want, or use it my version. Source code: https://lnkd.in/ggh8HffG If you try it and have suggestions I’d love feedback! #AI #LLM #PromptEngineering