eval and red teaming

Author: howieleung

src/gunicorn.conf.py

@@ -17,6 +17,18 @@
 from azure.core.credentials_async import AsyncTokenCredential
 from azure.ai.projects.models import AgentReference, PromptAgentDefinition
 from azure.ai.projects.models import FileSearchTool, AzureAISearchAgentTool, Tool, AgentVersionObject, AzureAISearchToolResource, AISearchIndexResource
+
+from azure.ai.projects.models import (
+    PromptAgentDefinition,
+    EvaluationRule,
+    ContinuousEvaluationRuleAction,
+    EvaluationRuleFilter,
+    EvaluationRuleEventType,
+    EvaluatorCategory,
+    EvaluatorDefinitionType
+)
+
+
 from openai import AsyncOpenAI
 from dotenv import load_dotenv
 
@@ -174,6 +186,95 @@ async def create_agent(ai_project: AIProjectClient,
     )
     return agent
 
+async def initialize_eval(project_client: AIProjectClient, agent: AgentVersionObject):
+    print("Creating a single evaluator version - Prompt based (json style)")
+    prompt_evaluator = await project_client.evaluators.create_version(
+        name="my_custom_evaluator_prompt",
+        evaluator_version={
+            "name": "my_custom_evaluator_prompt",
+            "categories": [EvaluatorCategory.QUALITY],
+            "display_name": "my_custom_evaluator_prompt",
+            "description": "Custom evaluator to for groundedness",
+            "definition": {
+                "type": EvaluatorDefinitionType.PROMPT,
+                "prompt_text": """
+                        You are a Groundedness Evaluator.
+
+                        Your task is to evaluate how well the given response is grounded in the provided ground truth.
+                        Groundedness means the response's statements are factually supported by the ground truth.
+                        Evaluate factual alignment only — ignore grammar, fluency, or completeness.
+
+                        ---
+
+                        ### Input:
+                        Query:
+                        {query}
+
+                        Response:
+                        {response}
+
+                        Ground Truth:
+                        {ground_truth}
+
+                        ---
+
+                        ### Scoring Scale (1-5):
+                        5 → Fully grounded. All claims supported by ground truth.  
+                        4 → Mostly grounded. Minor unsupported details.  
+                        3 → Partially grounded. About half the claims supported.  
+                        2 → Mostly ungrounded. Only a few details supported.  
+                        1 → Not grounded. Almost all information unsupported.
+
+                        ---
+
+                        ### Output should be Integer:
+                        <integer from 1 to 5>
+                """,
+                "init_parameters": {
+                    "type": "object",
+                    "properties": {"deployment_name": {"type": "string"}, "threshold": {"type": "number"}},
+                    "required": ["deployment_name"],
+                },
+                "data_schema": {
+                    "type": "object",
+                    "properties": {
+                        "query": {"type": "string"},
+                        "response": {"type": "string"},
+                        "ground_truth": {"type": "string"},
+                    },
+                    "required": ["query", "response", "ground_truth"],
+                },
+                "metrics": {
+                    "tool_selection": {
+                        "type": "ordinal",
+                        "desirable_direction": "increase",
+                        "min_value": 1,
+                        "max_value": 5,
+                    }
+                },
+            },
+        },
+    )
+
+    print(f"Evaluator version created (id: {prompt_evaluator.id}, name: {prompt_evaluator.name})")
+
+    print("Creating continuous evaluation rule to run evaluator on agent responses")
+    continuous_eval_rule = await project_client.evaluation_rules.create_or_update(
+        id="my-continuous-eval-rule",
+        evaluation_rule=EvaluationRule(
+            display_name="My Continuous Eval Rule",
+            description="An eval rule that runs on agent response completions",
+            action=ContinuousEvaluationRuleAction(eval_id=prompt_evaluator.id, max_hourly_runs=10),
+            event_type=EvaluationRuleEventType.RESPONSE_COMPLETED,
+            filter=EvaluationRuleFilter(agent_name=agent.name),
+            enabled=True,
+        ),
+    )
+    print(
+        f"Continuous Evaluation Rule created (id: {continuous_eval_rule.id}, name: {continuous_eval_rule.display_name})"
+    )
+
+
 
 async def initialize_resources():
     try:
@@ -196,7 +297,6 @@ async def initialize_resources():
                     agent_version = agentID.split(":")[1]
                     agent_obj = await ai_project.agents.retrieve_version(agent_name, agent_version)
                     logger.info(f"Found agent by ID: {agent_obj.id}")
-                    return
                 except Exception as e:
                     logger.warning(
                         "Could not retrieve agent by AZURE_EXISTING_AGENT_ID = "
@@ -222,6 +322,8 @@ async def initialize_resources():
 
             os.environ["AZURE_EXISTING_AGENT_ID"] = agent_obj.id
 
+            await initialize_eval(ai_project, agent_obj)                
+
     except Exception as e:
         logger.info("Error creating agent: {e}", exc_info=True)
         raise RuntimeError(f"Failed to create the agent: {e}")

tests/test_evaluation.py

@@ -0,0 +1,116 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+import os
+import time
+from pprint import pprint
+from dotenv import load_dotenv
+from azure.identity import DefaultAzureCredential
+from azure.ai.projects import AIProjectClient
+from openai.types.eval_create_params import DataSourceConfigCustom
+
+load_dotenv()
+
+agent_id = os.environ.get("AZURE_EXISTING_AGENT_ID", "")
+endpoint = os.environ.get("AZURE_EXISTING_AIPROJECT_ENDPOINT", "")
+
+if not agent_id or ":" not in agent_id:
+    raise ValueError("Please set AZURE_EXISTING_AGENT_ID environment variable in the format 'agent_name:agent_version'.")
+
+if not endpoint:
+    raise ValueError("Please set AZURE_EXISTING_AIPROJECT_ENDPOINT environment variable.")
+
+
+def test_evaluation():
+    project_client = AIProjectClient(
+        endpoint=endpoint,
+        credential=DefaultAzureCredential(),
+    )
+
+    agent_name = agent_id.split(":")[0]
+    agent_version = agent_id.split(":")[1]
+
+    with project_client:
+
+        openai_client = project_client.get_openai_client()
+
+        agent = project_client.agents.retrieve_version(
+            agent_name=agent_name, agent_version=agent_version
+        )
+        print(f"Agent retrieved (id: {agent.id}, name: {agent.name}, version: {agent.version})")
+
+        data_source_config = DataSourceConfigCustom(
+            type="custom",
+            item_schema={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]},
+            include_sample_schema=True,
+        )
+        testing_criteria = [
+            {
+                "type": "azure_ai_evaluator",
+                "name": "violence_detection",
+                "evaluator_name": "builtin.violence",
+                "data_mapping": {"query": "{{item.query}}", "response": "{{item.response}}"},
+            }
+        ]
+        eval_object = openai_client.evals.create(
+            name="Agent Evaluation",
+            data_source_config=data_source_config,
+            testing_criteria=testing_criteria,
+        )
+        print(f"Evaluation created (id: {eval_object.id}, name: {eval_object.name})")
+
+        data_source = {
+            "type": "azure_ai_target_completions",
+            "source": {
+                "type": "file_content",
+                "content": [
+                    {"item": {"query": "What is the capital of France?"}},
+                    {"item": {"query": "How do I reverse a string in Python?"}},
+                ],
+            },
+            "input_messages": {
+                "type": "template",
+                "template": [
+                    {"type": "message", "role": "user", "content": {"type": "input_text", "text": "{{item.query}}"}}
+                ],
+            },
+            "target": {
+                "type": "azure_ai_agent",
+                "name": agent.name,
+                "version": agent.version,  # Version is optional. Defaults to latest version if not specified
+            },
+        }
+
+        agent_eval_run = openai_client.evals.runs.create(
+            eval_id=eval_object.id, name=f"Evaluation Run for Agent {agent.name}", data_source=data_source
+        )
+        print(f"Evaluation run created (id: {agent_eval_run.id})")
+
+        while agent_eval_run.status not in ["completed", "failed"]:
+            agent_eval_run = openai_client.evals.runs.retrieve(run_id=agent_eval_run.id, eval_id=eval_object.id)
+            print(f"Waiting for eval run to complete... current status: {agent_eval_run.status}")
+            time.sleep(5)
+
+        if agent_eval_run.status == "completed":
+            print("\n✓ Evaluation run completed successfully!")
+            print(f"Result Counts: {agent_eval_run.result_counts}")
+
+            output_items = list(
+                openai_client.evals.runs.output_items.list(run_id=agent_eval_run.id, eval_id=eval_object.id)
+            )
+            print(f"\nOUTPUT ITEMS (Total: {len(output_items)})")
+            print(f"{'-'*60}")
+            pprint(output_items)
+            print(f"{'-'*60}")
+        else:
+            print("\n✗ Evaluation run failed.")
+
+        openai_client.evals.delete(eval_id=eval_object.id)
+        print("Evaluation deleted")
+
+        project_client.agents.delete(agent_name=agent.name)
+        print("Agent deleted")
+
+        assert True==True