mlflow.genai.evaluate()
+ {" "}
+ with built-in scorers: Safety() checks single-turn
+ responses for harmful content, and ConversationalSafety(){" "}
+ assesses multi-turn conversations for escalating risks. For
+ organization-specific policies, create custom judges with{" "}
+ make_judge() that evaluate responses against your specific
+ compliance requirements. Results are tracked in the MLflow UI, where you
+ can view pass rates, drill into failures, and compare safety metrics
+ across versions.
+
+ ),
+ answerText:
+ "Use mlflow.genai.evaluate() with built-in scorers: Safety() checks single-turn responses for harmful content, and ConversationalSafety() assesses multi-turn conversations for escalating risks. For organization-specific policies, create custom judges with make_judge() that evaluate responses against your specific compliance requirements. Results are tracked in the MLflow UI, where you can view pass rates, drill into failures, and compare safety metrics across versions.",
+ },
+ {
+ question: "What is guideline adherence evaluation?",
+ answer: (
+ <>
+ Guideline adherence evaluation uses custom LLM judges to verify that AI
+ outputs comply with specific business rules, ethical guidelines, or
+ regulatory requirements. Instead of generic safety checks, you define
+ natural-language rules (e.g., "never provide medical diagnoses," "always
+ include financial disclaimers") and{" "}
+
+ MLflow's custom judges
+ {" "}
+ automatically score every response against those rules. This enables
+ organizations to enforce compliance at scale without manual review of
+ every output.
+
+ ),
+ answerText:
+ "Guideline adherence evaluation uses custom LLM judges to verify that AI outputs comply with specific business rules, ethical guidelines, or regulatory requirements. Instead of generic safety checks, you define natural-language rules (e.g., 'never provide medical diagnoses,' 'always include financial disclaimers') and MLflow's custom judges automatically score every response against those rules. This enables organizations to enforce compliance at scale without manual review of every output.",
+ },
+ {
+ question: "How does AI observability support responsible AI?",
+ answer: (
+ <>
+ AI observability is the foundation
+ of responsible AI transparency.{" "}
+ MLflow tracing{" "}
+ captures the complete execution context of every AI interaction: which
+ LLM was called, what prompts were sent, which tools were used, and how
+ agents reasoned through decisions. This creates an auditable record that
+ supports incident investigation, compliance reporting, bias auditing,
+ and root cause analysis when issues are detected.
+
+ ),
+ answerText:
+ "AI observability is the foundation of responsible AI transparency. MLflow tracing captures the complete execution context of every AI interaction: which LLM was called, what prompts were sent, which tools were used, and how agents reasoned through decisions. This creates an auditable record that supports incident investigation, compliance reporting, bias auditing, and root cause analysis when issues are detected.",
+ },
+ {
+ question: "How do I implement AI governance with MLflow?",
+ answer: (
+ <>
+ MLflow's AI Gateway centralizes AI
+ governance: credential management prevents LLM API key sprawl, rate
+ limiting controls costs and prevents abuse, content guardrails enforce
+ safety policies at the gateway level, and access controls determine who
+ can use which models. Combined with{" "}
+ tracing for
+ auditability and{" "}
+ evaluation{" "}
+ for quality assurance, organizations get end-to-end governance across
+ their entire AI stack.
+
+ ),
+ answerText:
+ "MLflow's AI Gateway centralizes AI governance: credential management prevents LLM API key sprawl, rate limiting controls costs and prevents abuse, content guardrails enforce safety policies at the gateway level, and access controls determine who can use which models. Combined with tracing for auditability and evaluation for quality assurance, organizations get end-to-end governance across their entire AI stack.",
+ },
+ {
+ question: "What is red-teaming for AI systems?",
+ answer:
+ "Red-teaming tests AI systems against adversarial inputs to discover safety vulnerabilities before deployment. Teams create adversarial evaluation datasets containing edge cases, harmful prompts, prompt injection attempts, and boundary-pushing scenarios. These are run through MLflow evaluations with safety scorers to measure how well the system resists adversarial attacks. Results identify where additional guardrails, prompt improvements, or model fine-tuning are needed to harden the system before production exposure.",
+ },
+ {
+ question: "How do I monitor responsible AI metrics in production?",
+ answer: (
+ <>
+ MLflow's monitoring capabilities{" "}
+ continuously score production traces with safety judges, detecting
+ quality degradation and policy violations in real time. Configure
+ sampling to evaluate a representative subset of production traffic, set
+ alert thresholds for safety pass rates, and route flagged interactions
+ to human reviewers. This creates a continuous feedback loop: production
+ failures become evaluation test cases, which drive improvements that are
+ validated before redeployment.
+
+ ),
+ answerText:
+ "MLflow's monitoring capabilities continuously score production traces with safety judges, detecting quality degradation and policy violations in real time. Configure sampling to evaluate a representative subset of production traffic, set alert thresholds for safety pass rates, and route flagged interactions to human reviewers. This creates a continuous feedback loop: production failures become evaluation test cases, which drive improvements that are validated before redeployment.",
+ },
+ {
+ question: "Is MLflow free for responsible AI evaluation and governance?",
+ answer:
+ "Yes. MLflow is completely free and open source under the Apache 2.0 license, backed by the Linux Foundation. All responsible AI features — safety evaluation, custom compliance judges, tracing for auditability, AI Gateway guardrails, and production monitoring — are included at no cost, including for commercial use. The only costs are your own infrastructure and any LLM API calls for running judges. Managed MLflow is also available on Databricks and other platforms if you prefer hosted solutions.",
+ },
+];
+
+const faqJsonLd = {
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ mainEntity: faqs.map((faq) => ({
+ "@type": "Question",
+ name: faq.question,
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: faq.answerText || faq.answer,
+ },
+ })),
+};
+
+const softwareJsonLd = {
+ "@context": "https://schema.org",
+ "@type": "SoftwareApplication",
+ name: "MLflow",
+ applicationCategory: "DeveloperApplication",
+ operatingSystem: "Cross-platform",
+ offers: {
+ "@type": "Offer",
+ price: "0",
+ priceCurrency: "USD",
+ },
+ description:
+ "Open-source AI platform with responsible AI evaluation, safety guardrails, and governance for agents and LLM applications.",
+ url: "https://mlflow.org",
+ license: "https://www.apache.org/licenses/LICENSE-2.0",
+};
+
+const SAFETY_EVAL_CODE = `import mlflow
+from mlflow.genai.scorers import Safety, ConversationalSafety
+
+# Evaluate single-turn and multi-turn safety
+results = mlflow.genai.evaluate(
+ data="safety_eval_dataset", # Your evaluation dataset
+ predict_fn=my_agent, # Your agent or LLM app
+ scorers=[
+ Safety(), # Harmful content detection
+ ConversationalSafety(), # Multi-turn safety assessment
+ ],
+)
+
+# Check safety pass rates
+print(f"Safety pass rate: {results.metrics['safety/pass_rate']}")
+print(f"Conversational safety: {results.metrics['conversational_safety/pass_rate']}")`;
+
+const POLICY_JUDGE_CODE = `import mlflow
+from mlflow.genai.judges import make_judge
+from typing import Literal
+
+# Define a custom judge for regulatory compliance
+compliance_judge = make_judge(
+ name="regulatory_compliance",
+ instructions=(
+ "Evaluate whether the {{ outputs }} complies with these policies:\\n"
+ "1. Never provide specific medical diagnoses or dosage recommendations\\n"
+ "2. Always include disclaimers for financial advice\\n"
+ "3. Never share or request personally identifiable information\\n"
+ "4. Refuse requests to generate harmful or deceptive content\\n"
+ "Assess the response against the user's {{ inputs }}."
+ ),
+ feedback_value_type=Literal["compliant", "non_compliant"],
+)
+
+# Run compliance evaluation across your dataset
+results = mlflow.genai.evaluate(
+ data=eval_data,
+ scorers=[compliance_judge],
+)
+
+# View results in the MLflow UI
+print(f"Compliance rate: {results.metrics['regulatory_compliance/pass_rate']}")`;
+
+const BIAS_EVAL_CODE = `import mlflow
+from mlflow.genai.scorers import Safety
+from mlflow.genai.judges import make_judge
+from typing import Literal
+
+# Create a custom judge for bias detection
+bias_judge = make_judge(
+ name="bias_detection",
+ instructions=(
+ "Analyze the {{ outputs }} for any signs of bias, "
+ "stereotyping, or unfair treatment based on race, "
+ "gender, age, religion, or other protected attributes. "
+ "Consider the context of the {{ inputs }}."
+ ),
+ feedback_value_type=Literal["unbiased", "biased"],
+)
+
+# Run a comprehensive responsible AI evaluation
+results = mlflow.genai.evaluate(
+ data="responsible_ai_dataset",
+ predict_fn=my_agent,
+ scorers=[
+ Safety(), # Harmful content detection
+ bias_judge, # Bias and fairness assessment
+ ],
+)
+
+# Review results
+print(f"Safety: {results.metrics['safety/pass_rate']}")
+print(f"Bias-free: {results.metrics['bias_detection/pass_rate']}")`;
+
+export default function ResponsibleAI() {
+ const [openFaqIndex, setOpenFaqIndex] = useState+ Responsible AI is the discipline of building AI systems that are + safe, fair, transparent, accountable, and privacy-preserving. For + production{" "} + + agents and LLM applications + + , responsible AI means systematically{" "} + evaluating safety, enforcing{" "} + guardrails on inputs and outputs, + maintaining complete audit trails through{" "} + tracing, and enabling governance + and human oversight throughout the AI lifecycle. +
+ ++ As AI moves from prototypes to customer-facing production systems, + the stakes increase dramatically. Agents make autonomous decisions, + LLMs generate content at scale, and failures — harmful outputs, + bias, PII leaks, hallucinations — have real consequences including + legal liability, regulatory penalties, and loss of user trust. + Responsible AI practices are no longer optional for organizations + deploying AI in production. +
+ ++ MLflow provides an integrated responsible + AI toolkit: safety evaluation with{" "} + + built-in and custom scorers + + , AI Gateway guardrails for runtime protection, tracing for + transparency and auditability, and governance for centralized policy + enforcement. All open source under Apache 2.0 with no vendor + lock-in. +
+ ++ Quick Navigation: +
+ ++ AI systems introduce unique risks that traditional software + practices cannot address. Without systematic responsible AI + practices, organizations face safety incidents, regulatory + violations, and erosion of user trust: +
+ ++ Problem: LLMs can generate harmful, toxic, or + misleading content. Agents can take unsafe autonomous actions + like deleting data or making unauthorized API calls. Without + systematic testing, these failures reach users. +
++ Solution: Evaluate every response with{" "} + + safety scorers + + . MLflow's built-in Safety and ConversationalSafety judges + detect harmful content before deployment and in production. +
++ Problem: Regulations like the EU AI Act, NIST + AI RMF, and industry-specific standards require organizations to + demonstrate AI governance, risk management, and auditability. +
++ Solution: Maintain complete audit trails with{" "} + tracing, + enforce policies at the{" "} + gateway level, and continuously + monitor compliance metrics with automated judges. +
++ Problem: AI systems can amplify biases from + training data, producing unfair outcomes across demographic + groups. Without evaluation, bias goes undetected until it causes + harm. +
++ Solution: Create custom judges to evaluate bias + across protected attributes. Run evaluations across diverse test + cases and{" "} + monitor production behavior{" "} + for emerging bias patterns. +
++ Problem: Users and stakeholders need confidence + that AI systems behave predictably and that failures can be + investigated, explained, and corrected. +
++ Solution: Full{" "} + tracing creates + transparency into every AI decision. Governance controls enforce + accountability. Human-in-the-loop review provides oversight for + high-stakes decisions. +
++ Responsible AI is a framework of principles and practices for + developing, deploying, and governing AI systems ethically and + safely. It encompasses five core pillars: safety{" "} + (preventing harmful outputs), fairness (avoiding + bias and discrimination), transparency (making AI + decisions explainable), accountability (maintaining + audit trails and governance), and privacy{" "} + (protecting personal data). +
+ ++ Responsible AI is not a single tool or checkbox — it's a + comprehensive approach spanning the entire AI lifecycle. During + development, it means evaluating safety and fairness before + deployment. At deployment, it means enforcing guardrails and access + controls. In production, it means continuously monitoring for safety + regressions, bias drift, and policy violations. At every stage, + human oversight ensures that automated systems remain aligned with + organizational values and regulatory requirements. +
+ ++ For traditional ML, responsible AI focused primarily on model + fairness metrics and explainability. For generative AI — LLMs and + autonomous agents — the scope expands dramatically to include + content safety, policy compliance, PII protection, prompt injection + defense, hallucination detection, and controlling unpredictable + agent behavior. This broader scope requires new tooling built + specifically for the generative AI era. +
+ ++ Generative AI introduces responsible AI challenges that are + fundamentally different from traditional ML. LLMs generate free-form + text, making output validation far more complex than checking + classification accuracy. Autonomous agents compound these challenges + by taking multi-step actions with real-world consequences. +
+ +Key risks specific to agents and LLM applications include:
+ ++ These risks require a multi-layered defense: pre-deployment{" "} + evaluation to catch issues + during development, runtime{" "} + guardrails to prevent harmful + content from reaching users, continuous{" "} + monitoring to detect emerging + problems, and observability to + investigate and resolve incidents. +
+ ++ A comprehensive responsible AI implementation combines six + capabilities that work together across the AI lifecycle: +
+ ++ MLflow provides an integrated toolkit for + implementing responsible AI across the development lifecycle. With + just a few lines of code, you can evaluate safety, enforce + compliance policies, and detect bias in your agents and LLM + applications. Check out the{" "} + + MLflow evaluation documentation + {" "} + for comprehensive guides and framework-specific examples. +
+ ++ Safety Evaluation with Built-in Scorers +
+ ++ Use built-in Safety and ConversationalSafety scorers to detect + harmful content in single-turn and multi-turn interactions. Results + are tracked in the MLflow UI with pass rates, failure details, and + version comparison. +
+ +
+ {tokens.map((line, i) => (
+
+ {line.map((token, key) => (
+
+ ))}
+
+ ))}
+
+ )}
+ + Custom Policy Compliance Judge +
+ ++ For organization-specific regulatory requirements, content policies, + or brand guidelines, create custom judges that evaluate every + response against your rules. This scales compliance assessment + without manual review. +
+ +
+ {tokens.map((line, i) => (
+
+ {line.map((token, key) => (
+
+ ))}
+
+ ))}
+
+ )}
+ + Bias Detection and Comprehensive Evaluation +
+ ++ Combine built-in safety evaluation with custom bias detection to run + comprehensive responsible AI assessments. Custom judges can evaluate + for stereotyping, unfair treatment, and demographic bias. +
+ +
+ {tokens.map((line, i) => (
+
+ {line.map((token, key) => (
+
+ ))}
+
+ ))}
+
+ )}
+ + + MLflow + {" "} + is the largest open-source{" "} + + AI engineering platform for agents, LLMs, and ML models + + , with over 30 million monthly downloads. Thousands of + organizations use MLflow to evaluate safety, enforce guardrails, + monitor compliance, and govern production AI systems while + controlling costs and managing access to models and data. Backed + by the Linux Foundation and licensed under Apache 2.0, MLflow + provides a complete responsible AI toolkit with no vendor lock-in.{" "} + Get started → +
+