azure-ai-evaluation 1.6.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

azure/ai/evaluation/red_team/_red_team.py

@@ -39,6 +39,7 @@ from azure.ai.evaluation._exceptions import ErrorBlame, ErrorCategory, ErrorTarg
 from azure.ai.evaluation._common.math import list_mean_nan_safe, is_none_or_nan
 from azure.ai.evaluation._common.utils import validate_azure_ai_project, is_onedp_project
 from azure.ai.evaluation import evaluate
+from azure.ai.evaluation._common import RedTeamUpload, ResultType
 
 # Azure Core imports
 from azure.core.credentials import TokenCredential
@@ -77,7 +78,7 @@ from ._utils.logging_utils import (
 )
 
 @experimental
-class RedTeam():
+class RedTeam:
     """
     This class uses various attack strategies to test the robustness of AI models against adversarial inputs.
     It logs the results of these evaluations and provides detailed scorecards summarizing the attack success rates.
@@ -215,11 +216,12 @@ class RedTeam():
         self.azure_ai_project = validate_azure_ai_project(azure_ai_project)
         self.credential = credential
         self.output_dir = output_dir
-        
+        self._one_dp_project = is_onedp_project(azure_ai_project)
+
         # Initialize logger without output directory (will be updated during scan)
         self.logger = setup_logger()
         
-        if not is_onedp_project(azure_ai_project):
+        if not self._one_dp_project:
             self.token_manager = ManagedIdentityAPITokenManager(
                 token_scope=TokenScope.DEFAULT_AZURE_MANAGEMENT,
                 logger=logging.getLogger("RedTeamLogger"),
@@ -276,52 +278,67 @@ class RedTeam():
         :raises EvaluationException: If no azure_ai_project is provided or trace destination cannot be determined
         """
         if not azure_ai_project:
-            log_error(self.logger, "No azure_ai_project provided, cannot start MLFlow run")
+            log_error(self.logger, "No azure_ai_project provided, cannot upload run")
             raise EvaluationException(
                 message="No azure_ai_project provided",
                 blame=ErrorBlame.USER_ERROR,
                 category=ErrorCategory.MISSING_FIELD,
                 target=ErrorTarget.RED_TEAM
             )
-        
-        trace_destination = _trace_destination_from_project_scope(azure_ai_project)
-        if not trace_destination:
-            self.logger.warning("Could not determine trace destination from project scope")
-            raise EvaluationException(
-                message="Could not determine trace destination",
-                blame=ErrorBlame.SYSTEM_ERROR,
-                category=ErrorCategory.UNKNOWN,
-                target=ErrorTarget.RED_TEAM
+
+        if self._one_dp_project:
+            response = self.generated_rai_client._evaluation_onedp_client.start_red_team_run(
+                red_team=RedTeamUpload(
+                    scan_name=run_name or f"redteam-agent-{datetime.now().strftime('%Y%m%d-%H%M%S')}",
+                )
             )
-        
-        ws_triad = extract_workspace_triad_from_trace_provider(trace_destination)
-        
-        management_client = LiteMLClient(
-            subscription_id=ws_triad.subscription_id,
-            resource_group=ws_triad.resource_group_name,
-            logger=self.logger,
-            credential=azure_ai_project.get("credential")
-        )
-        
-        tracking_uri = management_client.workspace_get_info(ws_triad.workspace_name).ml_flow_tracking_uri
-        
-        run_display_name = run_name or f"redteam-agent-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
-        self.logger.debug(f"Starting MLFlow run with name: {run_display_name}")
-        eval_run = EvalRun(
-            run_name=run_display_name,
-            tracking_uri=cast(str, tracking_uri),
-            subscription_id=ws_triad.subscription_id,
-            group_name=ws_triad.resource_group_name,
-            workspace_name=ws_triad.workspace_name,
-            management_client=management_client, # type: ignore
-        )
-        eval_run._start_run()
-        self.logger.debug(f"MLFlow run started successfully with ID: {eval_run.info.run_id}")
 
-        self.trace_destination = trace_destination
-        self.logger.debug(f"MLFlow run created successfully with ID: {eval_run}")
-    
-        return eval_run
+            self.ai_studio_url = response.properties.get("AiStudioEvaluationUri")
+
+            return response
+
+        else:
+            trace_destination = _trace_destination_from_project_scope(azure_ai_project)
+            if not trace_destination:
+                self.logger.warning("Could not determine trace destination from project scope")
+                raise EvaluationException(
+                    message="Could not determine trace destination",
+                    blame=ErrorBlame.SYSTEM_ERROR,
+                    category=ErrorCategory.UNKNOWN,
+                    target=ErrorTarget.RED_TEAM
+                )
+
+            ws_triad = extract_workspace_triad_from_trace_provider(trace_destination)
+
+            management_client = LiteMLClient(
+                subscription_id=ws_triad.subscription_id,
+                resource_group=ws_triad.resource_group_name,
+                logger=self.logger,
+                credential=azure_ai_project.get("credential")
+            )
+
+            tracking_uri = management_client.workspace_get_info(ws_triad.workspace_name).ml_flow_tracking_uri
+
+            run_display_name = run_name or f"redteam-agent-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+            self.logger.debug(f"Starting MLFlow run with name: {run_display_name}")
+            eval_run = EvalRun(
+                run_name=run_display_name,
+                tracking_uri=cast(str, tracking_uri),
+                subscription_id=ws_triad.subscription_id,
+                group_name=ws_triad.resource_group_name,
+                workspace_name=ws_triad.workspace_name,
+                management_client=management_client, # type: ignore
+            )
+            eval_run._start_run()
+            self.logger.debug(f"MLFlow run started successfully with ID: {eval_run.info.run_id}")
+
+            self.trace_destination = trace_destination
+            self.logger.debug(f"MLFlow run created successfully with ID: {eval_run}")
+
+            self.ai_studio_url = _get_ai_studio_url(trace_destination=self.trace_destination,
+                                                    evaluation_id=eval_run.info.run_id)
+
+            return eval_run
 
 
     async def _log_redteam_results_to_mlflow(
@@ -343,58 +360,59 @@ class RedTeam():
         """
         self.logger.debug(f"Logging results to MLFlow, _skip_evals={_skip_evals}")
         artifact_name = "instance_results.json"
+        eval_info_name = "redteam_info.json"
+        properties = {}
 
         # If we have a scan output directory, save the results there first
-        if hasattr(self, 'scan_output_dir') and self.scan_output_dir:
-            artifact_path = os.path.join(self.scan_output_dir, artifact_name)
-            self.logger.debug(f"Saving artifact to scan output directory: {artifact_path}")
-            with open(artifact_path, "w", encoding=DefaultOpenEncoding.WRITE) as f:
-                if _skip_evals:
-                    # In _skip_evals mode, we write the conversations in conversation/messages format
-                    f.write(json.dumps({"conversations": redteam_result.attack_details or []}))
-                elif redteam_result.scan_result:
-                    # Create a copy to avoid modifying the original scan result
-                    result_with_conversations = redteam_result.scan_result.copy() if isinstance(redteam_result.scan_result, dict) else {}
-                    
-                    # Preserve all original fields needed for scorecard generation
-                    result_with_conversations["scorecard"] = result_with_conversations.get("scorecard", {})
-                    result_with_conversations["parameters"] = result_with_conversations.get("parameters", {})
-                    
-                    # Add conversations field with all conversation data including user messages
-                    result_with_conversations["conversations"] = redteam_result.attack_details or []
-                    
-                    # Keep original attack_details field to preserve compatibility with existing code
-                    if "attack_details" not in result_with_conversations and redteam_result.attack_details is not None:
-                        result_with_conversations["attack_details"] = redteam_result.attack_details
-                    
-                    json.dump(result_with_conversations, f)
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmpdir:
+            if hasattr(self, 'scan_output_dir') and self.scan_output_dir:
+                artifact_path = os.path.join(self.scan_output_dir, artifact_name)
+                self.logger.debug(f"Saving artifact to scan output directory: {artifact_path}")
+                with open(artifact_path, "w", encoding=DefaultOpenEncoding.WRITE) as f:
+                    if _skip_evals:
+                        # In _skip_evals mode, we write the conversations in conversation/messages format
+                        f.write(json.dumps({"conversations": redteam_result.attack_details or []}))
+                    elif redteam_result.scan_result:
+                        # Create a copy to avoid modifying the original scan result
+                        result_with_conversations = redteam_result.scan_result.copy() if isinstance(redteam_result.scan_result, dict) else {}
+                        
+                        # Preserve all original fields needed for scorecard generation
+                        result_with_conversations["scorecard"] = result_with_conversations.get("scorecard", {})
+                        result_with_conversations["parameters"] = result_with_conversations.get("parameters", {})
+                        
+                        # Add conversations field with all conversation data including user messages
+                        result_with_conversations["conversations"] = redteam_result.attack_details or []
+                        
+                        # Keep original attack_details field to preserve compatibility with existing code
+                        if "attack_details" not in result_with_conversations and redteam_result.attack_details is not None:
+                            result_with_conversations["attack_details"] = redteam_result.attack_details
+                        
+                        json.dump(result_with_conversations, f)
 
-            eval_info_name = "redteam_info.json"
-            eval_info_path = os.path.join(self.scan_output_dir, eval_info_name)
-            self.logger.debug(f"Saving evaluation info to scan output directory: {eval_info_path}")
-            with open(eval_info_path, "w", encoding=DefaultOpenEncoding.WRITE) as f:
-                # Remove evaluation_result from red_team_info before logging
-                red_team_info_logged = {}
-                for strategy, harms_dict in self.red_team_info.items():
-                    red_team_info_logged[strategy] = {}
-                    for harm, info_dict in harms_dict.items():
-                        info_dict.pop("evaluation_result", None)
-                        red_team_info_logged[strategy][harm] = info_dict
-                f.write(json.dumps(red_team_info_logged))
-            
-            # Also save a human-readable scorecard if available
-            if not _skip_evals and redteam_result.scan_result:
-                scorecard_path = os.path.join(self.scan_output_dir, "scorecard.txt")
-                with open(scorecard_path, "w", encoding=DefaultOpenEncoding.WRITE) as f:
-                    f.write(self._to_scorecard(redteam_result.scan_result))
-                self.logger.debug(f"Saved scorecard to: {scorecard_path}")
+                eval_info_path = os.path.join(self.scan_output_dir, eval_info_name)
+                self.logger.debug(f"Saving evaluation info to scan output directory: {eval_info_path}")
+                with open(eval_info_path, "w", encoding=DefaultOpenEncoding.WRITE) as f:
+                    # Remove evaluation_result from red_team_info before logging
+                    red_team_info_logged = {}
+                    for strategy, harms_dict in self.red_team_info.items():
+                        red_team_info_logged[strategy] = {}
+                        for harm, info_dict in harms_dict.items():
+                            info_dict.pop("evaluation_result", None)
+                            red_team_info_logged[strategy][harm] = info_dict
+                    f.write(json.dumps(red_team_info_logged))
                 
-            # Create a dedicated artifacts directory with proper structure for MLFlow
-            # MLFlow requires the artifact_name file to be in the directory we're logging
-            
-            import tempfile
-            with tempfile.TemporaryDirectory() as tmpdir:
-                # First, create the main artifact file that MLFlow expects
+                # Also save a human-readable scorecard if available
+                if not _skip_evals and redteam_result.scan_result:
+                    scorecard_path = os.path.join(self.scan_output_dir, "scorecard.txt")
+                    with open(scorecard_path, "w", encoding=DefaultOpenEncoding.WRITE) as f:
+                        f.write(self._to_scorecard(redteam_result.scan_result))
+                    self.logger.debug(f"Saved scorecard to: {scorecard_path}")
+                    
+                # Create a dedicated artifacts directory with proper structure for MLFlow
+                # MLFlow requires the artifact_name file to be in the directory we're logging
+                
+                    # First, create the main artifact file that MLFlow expects
                 with open(os.path.join(tmpdir, artifact_name), "w", encoding=DefaultOpenEncoding.WRITE) as f:
                     if _skip_evals:
                         f.write(json.dumps({"conversations": redteam_result.attack_details or []}))
@@ -425,51 +443,89 @@ class RedTeam():
                         self.logger.warning(f"Failed to copy file {file} to artifact directory: {str(e)}")
                 
                 # Log the entire directory to MLFlow
-                try:
-                    eval_run.log_artifact(tmpdir, artifact_name)
-                    eval_run.log_artifact(tmpdir, eval_info_name)
-                    self.logger.debug(f"Successfully logged artifacts directory to MLFlow")
-                except Exception as e:
-                    self.logger.warning(f"Failed to log artifacts to MLFlow: {str(e)}")
-            
-            # Also log a direct property to capture the scan output directory
-            try:
-                eval_run.write_properties_to_run_history({"scan_output_dir": str(self.scan_output_dir)})
-                self.logger.debug("Logged scan_output_dir property to MLFlow")
-            except Exception as e:
-                self.logger.warning(f"Failed to log scan_output_dir property to MLFlow: {str(e)}")
-        else:
-            # Use temporary directory as before if no scan output directory exists
-            with tempfile.TemporaryDirectory() as tmpdir:
+                # try:
+                #     eval_run.log_artifact(tmpdir, artifact_name)
+                #     eval_run.log_artifact(tmpdir, eval_info_name)
+                #     self.logger.debug(f"Successfully logged artifacts directory to MLFlow")
+                # except Exception as e:
+                #     self.logger.warning(f"Failed to log artifacts to MLFlow: {str(e)}")
+
+                properties.update({"scan_output_dir": str(self.scan_output_dir)})
+            else:
+                # Use temporary directory as before if no scan output directory exists
                 artifact_file = Path(tmpdir) / artifact_name
                 with open(artifact_file, "w", encoding=DefaultOpenEncoding.WRITE) as f:
                     if _skip_evals:
                         f.write(json.dumps({"conversations": redteam_result.attack_details or []}))
                     elif redteam_result.scan_result:
                         json.dump(redteam_result.scan_result, f)
-                eval_run.log_artifact(tmpdir, artifact_name)
+                # eval_run.log_artifact(tmpdir, artifact_name)
                 self.logger.debug(f"Logged artifact: {artifact_name}")
 
-        eval_run.write_properties_to_run_history({
-            EvaluationRunProperties.RUN_TYPE: "eval_run",
-            "redteaming": "asr", # Red team agent specific run properties to help UI identify this as a redteaming run
-            EvaluationRunProperties.EVALUATION_SDK: f"azure-ai-evaluation:{VERSION}",
-            "_azureml.evaluate_artifacts": json.dumps([{"path": artifact_name, "type": "table"}]),
-        })
+            properties.update({
+                "redteaming": "asr", # Red team agent specific run properties to help UI identify this as a redteaming run
+                EvaluationRunProperties.EVALUATION_SDK: f"azure-ai-evaluation:{VERSION}",
+            })
+        
+            metrics = {}
+            if redteam_result.scan_result:
+                scorecard = redteam_result.scan_result["scorecard"]
+                joint_attack_summary = scorecard["joint_risk_attack_summary"]
+                
+                if joint_attack_summary:
+                    for risk_category_summary in joint_attack_summary:
+                        risk_category = risk_category_summary.get("risk_category").lower()
+                        for key, value in risk_category_summary.items():
+                            if key != "risk_category":
+                                metrics.update({
+                                    f"{risk_category}_{key}": cast(float, value)
+                                })
+                                # eval_run.log_metric(f"{risk_category}_{key}", cast(float, value))
+                                self.logger.debug(f"Logged metric: {risk_category}_{key} = {value}")
+
+            if self._one_dp_project:
+                try:
+                    create_evaluation_result_response = self.generated_rai_client._evaluation_onedp_client.create_evaluation_result(
+                        name=uuid.uuid4(),
+                        path=tmpdir,
+                        metrics=metrics,
+                        result_type=ResultType.REDTEAM
+                    )
+
+                    update_run_response = self.generated_rai_client._evaluation_onedp_client.update_red_team_run(
+                        name=eval_run.id,
+                        red_team=RedTeamUpload(
+                            id=eval_run.id,
+                            scan_name=eval_run.scan_name or f"redteam-agent-{datetime.now().strftime('%Y%m%d-%H%M%S')}",
+                            status="Completed",
+                            outputs={
+                                'evaluationResultId': create_evaluation_result_response.id,
+                            },
+                            properties=properties,
+                        )
+                    )
+                    self.logger.debug(f"Updated UploadRun: {update_run_response.id}")
+                except Exception as e:
+                    self.logger.warning(f"Failed to upload red team results to AI Foundry: {str(e)}")
+            else:
+                # Log the entire directory to MLFlow
+                try:
+                    eval_run.log_artifact(tmpdir, artifact_name)
+                    if hasattr(self, 'scan_output_dir') and self.scan_output_dir:
+                        eval_run.log_artifact(tmpdir, eval_info_name)
+                    self.logger.debug(f"Successfully logged artifacts directory to AI Foundry")
+                except Exception as e:
+                    self.logger.warning(f"Failed to log artifacts to AI Foundry: {str(e)}")
+
+                for k,v in metrics.items():
+                    eval_run.log_metric(k, v)
+                    self.logger.debug(f"Logged metric: {k} = {v}")
+
+                eval_run.write_properties_to_run_history(properties)
+
+                eval_run._end_run("FINISHED")
 
-        if redteam_result.scan_result:
-            scorecard = redteam_result.scan_result["scorecard"]
-            joint_attack_summary = scorecard["joint_risk_attack_summary"]
-            
-            if joint_attack_summary:
-                for risk_category_summary in joint_attack_summary:
-                    risk_category = risk_category_summary.get("risk_category").lower()
-                    for key, value in risk_category_summary.items():
-                        if key != "risk_category":
-                            eval_run.log_metric(f"{risk_category}_{key}", cast(float, value))
-                            self.logger.debug(f"Logged metric: {risk_category}_{key} = {value}")
-        eval_run._end_run("FINISHED")
-        self.logger.info("Successfully logged results to MLFlow")
+        self.logger.info("Successfully logged results to AI Foundry")
         return None
 
     # Using the utility function from strategy_utils.py instead
@@ -1993,10 +2049,9 @@ class RedTeam():
         else:
             eval_run = self._start_redteam_mlflow_run(self.azure_ai_project, scan_name)
 
-            self.ai_studio_url = _get_ai_studio_url(trace_destination=self.trace_destination, evaluation_id=eval_run.info.run_id)
             # Show URL for tracking progress
             print(f"🔗 Track your red team scan in AI Foundry: {self.ai_studio_url}")
-            self.logger.info(f"Started MLFlow run: {self.ai_studio_url}")
+            self.logger.info(f"Started Uploading run: {self.ai_studio_url}")
         
         log_subsection_header(self.logger, "Setting up scan configuration")
         flattened_attack_strategies = self._get_flattened_attack_strategies(attack_strategies)
@@ -2210,7 +2265,7 @@ class RedTeam():
         )
         
         if not skip_upload:
-            self.logger.info("Logging results to MLFlow")
+            self.logger.info("Logging results to AI Foundry")
             await self._log_redteam_results_to_mlflow(
                 redteam_result=output,
                 eval_run=eval_run,

azure/ai/evaluation/simulator/_conversation/constants.py

@@ -12,7 +12,7 @@ OUTPUT_FILE = "openai_api_response.jsonl"
 
 # Azure endpoint constants
 AZUREML_TOKEN_SCOPE = "https://ml.azure.com"
-COGNITIVE_SERVICES_TOKEN_SCOPE = "https://cognitiveservices.azure.com/"
+COGNITIVE_SERVICES_TOKEN_SCOPE = "https://ai.azure.com/"
 AZURE_TOKEN_REFRESH_INTERVAL = 600  # seconds
 AZURE_ENDPOINT_DOMAIN_VALID_PATTERN_RE = (
     r"^(?=.{1,255}$)(?!-)[a-zA-Z0-9-]{1,63}(?<!-)"

azure/ai/evaluation/simulator/_direct_attack_simulator.py

@@ -28,9 +28,9 @@ class DirectAttackSimulator:
     Initialize a UPIA (user prompt injected attack) jailbreak adversarial simulator with a project scope.
     This simulator converses with your AI system using prompts designed to interrupt normal functionality.
 
-    :param azure_ai_project: The scope of the Azure AI project. It contains subscription id, resource group, and project
-        name.
-    :type azure_ai_project: ~azure.ai.evaluation.AzureAIProject
+    :param azure_ai_project: The Azure AI project, which can either be a string representing the project endpoint 
+        or an instance of AzureAIProject. It contains subscription id, resource group, and project name. 
+    :type azure_ai_project: Union[str, AzureAIProject]
     :param credential: The credential for connecting to Azure AI project.
     :type credential: ~azure.core.credentials.TokenCredential
 

azure/ai/evaluation/simulator/_indirect_attack_simulator.py

@@ -30,9 +30,9 @@ class IndirectAttackSimulator(AdversarialSimulator):
     """
     Initializes the XPIA (cross domain prompt injected attack) jailbreak adversarial simulator with a project scope.
 
-    :param azure_ai_project: The scope of the Azure AI project. It contains subscription id, resource group, and project
-        name.
-    :type azure_ai_project: ~azure.ai.evaluation.AzureAIProject
+    :param azure_ai_project: The Azure AI project, which can either be a string representing the project endpoint 
+        or an instance of AzureAIProject. It contains subscription id, resource group, and project name. 
+    :type azure_ai_project: Union[str, AzureAIProject]
     :param credential: The credential for connecting to Azure AI project.
     :type credential: ~azure.core.credentials.TokenCredential
 

azure/ai/evaluation/simulator/_model_tools/_generated_rai_client.py

@@ -12,6 +12,7 @@ from azure.ai.evaluation._common.raiclient import MachineLearningServicesClient
 from azure.ai.evaluation._constants import TokenScope
 from azure.ai.evaluation._common.utils import is_onedp_project
 from azure.ai.evaluation._common.onedp import AIProjectClient
+from azure.ai.evaluation._common import EvaluationServiceOneDPClient
 import jwt
 import time
 import ast
@@ -46,6 +47,7 @@ class GeneratedRAIClient:
             ).rai_svc
         else:
             self._client = AIProjectClient(endpoint=azure_ai_project, credential=token_manager).red_teams
+            self._evaluation_onedp_client = EvaluationServiceOneDPClient(endpoint=azure_ai_project, credential=token_manager)
         
     def _get_service_discovery_url(self):
         """Get the service discovery URL.

azure/ai/evaluation/simulator/_model_tools/_template_handler.py

@@ -146,12 +146,13 @@ class AdversarialTemplate:
 
 class AdversarialTemplateHandler:
     """
-    Adversarial template handler constructor.
+    Initialize the AdversarialTemplateHandler.
 
-    :param azure_ai_project: The Azure AI project.
-    :type azure_ai_project: ~azure.ai.evaluation.AzureAIProject
-    :param rai_client: The RAI client.
-    :type rai_client: ~azure.ai.evaluation.simulator._model_tools.RAIClient
+    :param azure_ai_project: The Azure AI project, which can either be a string representing the project endpoint 
+        or an instance of AzureAIProject. It contains subscription id, resource group, and project name. 
+    :type azure_ai_project: Union[str, AzureAIProject]
+    :param rai_client: The RAI client or AI Project client used for fetching parameters.
+    :type rai_client: Union[~azure.ai.evaluation.simulator._model_tools.RAIClient, ~azure.ai.evaluation._common.onedp._client.AIProjectClient]
     """
 
     def __init__(self, azure_ai_project: Union[str, AzureAIProject], rai_client: Union[RAIClient, AIProjectClient]) -> None:

{azure_ai_evaluation-1.6.0.dist-info → azure_ai_evaluation-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-ai-evaluation
-Version: 1.6.0
+Version: 1.7.0
 Summary: Microsoft Azure Evaluation Library for Python
 Home-page: https://github.com/Azure/azure-sdk-for-python
 Author: Microsoft Corporation
@@ -30,10 +30,11 @@ Requires-Dist: nltk>=3.9.1
 Requires-Dist: azure-storage-blob>=12.10.0
 Requires-Dist: httpx>=0.25.1
 Requires-Dist: pandas<3.0.0,>=2.1.2
-Requires-Dist: openai>=1.73.0
+Requires-Dist: openai>=1.78.0
 Requires-Dist: ruamel.yaml<1.0.0,>=0.17.10
 Requires-Dist: msrest>=0.6.21
 Requires-Dist: Jinja2>=3.1.6
+Requires-Dist: aiohttp>=3.0
 Provides-Extra: redteam
 Requires-Dist: pyrit==0.8.1; extra == "redteam"
 
@@ -115,13 +116,23 @@ result = relevance_evaluator(
     response="The capital of Japan is Tokyo."
 )
 
-# AI assisted safety evaluator
+# There are two ways to provide Azure AI Project.
+# Option #1 : Using Azure AI Project Details 
 azure_ai_project = {
     "subscription_id": "<subscription_id>",
     "resource_group_name": "<resource_group_name>",
     "project_name": "<project_name>",
 }
 
+violence_evaluator = ViolenceEvaluator(azure_ai_project)
+result = violence_evaluator(
+    query="What is the capital of France?",
+    response="Paris."
+)
+
+# Option # 2 : Using Azure AI Project Url 
+azure_ai_project = "https://{resource_name}.services.ai.azure.com/api/projects/{project_name}"
+
 violence_evaluator = ViolenceEvaluator(azure_ai_project)
 result = violence_evaluator(
     query="What is the capital of France?",
@@ -272,11 +283,18 @@ with open("simulator_output.jsonl", "w") as f:
 ```python
 from azure.ai.evaluation.simulator import AdversarialSimulator, AdversarialScenario
 from azure.identity import DefaultAzureCredential
+
+# There are two ways to provide Azure AI Project.
+# Option #1 : Using Azure AI Project 
 azure_ai_project = {
     "subscription_id": <subscription_id>,
     "resource_group_name": <resource_group_name>,
     "project_name": <project_name>
 }
+
+# Option #2 : Using Azure AI Project Url 
+azure_ai_project = "https://{resource_name}.services.ai.azure.com/api/projects/{project_name}"
+
 scenario = AdversarialScenario.ADVERSARIAL_QA
 simulator = AdversarialSimulator(azure_ai_project=azure_ai_project, credential=DefaultAzureCredential())
 
@@ -382,6 +400,11 @@ This project has adopted the [Microsoft Open Source Code of Conduct][code_of_con
 
 # Release History
 
+## 1.7.0 (2025-05-12)
+
+### Bugs Fixed
+- azure-ai-evaluation failed with module not found [#40992](https://github.com/Azure/azure-sdk-for-python/issues/40992)
+
 ## 1.6.0 (2025-05-07)
 
 ### Features Added