Запуск агента AI для красных команд в облаке

pip install "azure-ai-projects>=2.0.0"

В дальнейшем задайте переменные среды для ресурсов Microsoft Foundry.

import os

endpoint = os.environ["AZURE_AI_PROJECT_ENDPOINT"]  # Example: https://<account_name>.services.ai.azure.com/api/projects/<project_name>
agent_name = os.environ["AZURE_AI_AGENT_NAME"]  # Required. The name of the agent to red team.

npm install @azure/ai-projects @azure/identity dotenv

Затем задайте переменные среды для Microsoft ресурсов Foundry и создайте клиент проекта:

import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";
import "dotenv/config";

// Example: https://<account_name>.services.ai.azure.com/api/projects/<project_name>
const projectEndpoint = process.env["AZURE_AI_PROJECT_ENDPOINT"] || "";
// Required. The name of the agent to red team.
const agentName = process.env["AZURE_AI_AGENT_NAME"] || "";
const modelDeploymentName = process.env["AZURE_AI_MODEL_DEPLOYMENT_NAME"] || "";

const project = new AIProjectClient(
  projectEndpoint,
  new DefaultAzureCredential(),
);
const openAIClient = project.getOpenAIClient();

Справочник: класс AIProjectClient

Установите cURL и Azure CLI. В примерах cURL замените заполнители адреса конечной точки проекта и элемент <token> токеном доступа для https://ai.azure.com.

import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

endpoint = os.environ["AZURE_AI_PROJECT_ENDPOINT"]
model_deployment = os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"]

with DefaultAzureCredential() as credential:
    with AIProjectClient(endpoint=endpoint, credential=credential) as project_client:
        client = project_client.get_openai_client()

        # Create a red team with built-in safety evaluators
        red_team = client.evals.create(
            name="Red Team Agentic Safety Evaluation",
            data_source_config={"type": "azure_ai_source", "scenario": "red_team"},
            testing_criteria=[
                {
                    "type": "azure_ai_evaluator",
                    "name": "Prohibited Actions",
                    "evaluator_name": "builtin.prohibited_actions",
                    "evaluator_version": "1"
                },
                {
                    "type": "azure_ai_evaluator",
                    "name": "Task Adherence",
                    "evaluator_name": "builtin.task_adherence",
                    "evaluator_version": "1",
                    "initialization_parameters": {"deployment_name": model_deployment},
                },
                {
                    "type": "azure_ai_evaluator",
                    "name": "Sensitive Data Leakage",
                    "evaluator_name": "builtin.sensitive_data_leakage",
                    "evaluator_version": "1"
                },
            ],
        )
        print(f"Created red team: {red_team.id}")

// Get the agent safety testing criteria used for red teaming
function getAgentSafetyEvaluationCriteria() {
  return [
    {
      type: "azure_ai_evaluator",
      name: "Prohibited Actions",
      evaluator_name: "builtin.prohibited_actions",
      evaluator_version: "1",
    },
    {
      type: "azure_ai_evaluator",
      name: "Task Adherence",
      evaluator_name: "builtin.task_adherence",
      evaluator_version: "1",
      initialization_parameters: { deployment_name: modelDeploymentName },
    },
    {
      type: "azure_ai_evaluator",
      name: "Sensitive Data Leakage",
      evaluator_name: "builtin.sensitive_data_leakage",
      evaluator_version: "1",
    },
  ];
}

// Create a red team with built-in safety evaluators
const redTeam = await openAIClient.evals.create({
  name: "Red Team Agentic Safety Evaluation",
  data_source_config: { type: "azure_ai_source", scenario: "red_team" },
  testing_criteria: getAgentSafetyEvaluationCriteria(),
});
console.log(`Created red team: ${redTeam.id}`);

curl --request POST \
  --url 'https://{{account}}.services.ai.azure.com/api/projects/{{project}}/openai/evals?api-version=2025-11-15-preview' \
  --header 'authorization: Bearer <token>' \
  --header 'content-type: application/json' \
  --data '{
  "name": "Red Team Safety Evaluation",
  "data_source_config": {
    "type": "azure_ai_source",
    "scenario": "red_team"
  },
  "testing_criteria": [
    {
      "type": "azure_ai_evaluator",
      "name": "Prohibited Actions",
      "evaluator_name": "builtin.prohibited_actions",
      "evaluator_version": "1"
    },
    {
      "type": "azure_ai_evaluator",
      "name": "Task Adherence",
      "evaluator_name": "builtin.task_adherence",
      "evaluator_version": "1",
      "initialization_parameters": {
        "deployment_name": "{{model_deployment}}"
      }
    },
    {
      "type": "azure_ai_evaluator",
      "name": "Sensitive Data Leakage",
      "evaluator_name": "builtin.sensitive_data_leakage",
      "evaluator_version": "1"
    }
  ]
}'

print(f"[Group] Retrieving group by id={red_team.id} ...")
red_team_fetched = client.evals.retrieve(red_team.id)
print("[Group] Response:")
print(red_team_fetched)

console.log(`[Group] Retrieving group by id=${redTeam.id} ...`);
const redTeamFetched = await openAIClient.evals.retrieve(redTeam.id);
console.log("[Group] Response:");
console.log(JSON.stringify(redTeamFetched, null, 2));

curl --request GET \
  --url 'https://{{account}}.services.ai.azure.com/api/projects/{{project}}/openai/evals/{{red_team_id}}?api-version=2025-11-15-preview' \
  --header 'authorization: Bearer <token>'

from azure.ai.projects.models import (
    AzureAIAgentTarget,
    AgentTaxonomyInput,
    EvaluationTaxonomy,
    RiskCategory,
)

# Define the agent target for taxonomy generation
target = AzureAIAgentTarget(
    name=agent_name,
    version=agent_version.version,
)

# Create taxonomy for prohibited actions risk category
taxonomy = project_client.beta.evaluation_taxonomies.create(
    name=agent_name,
    body=EvaluationTaxonomy(
        description="Taxonomy for red teaming run",
        taxonomy_input=AgentTaxonomyInput(
            risk_categories=[RiskCategory.PROHIBITED_ACTIONS],
            target=target
        ),
    )
)
taxonomy_file_id = taxonomy.id
print(f"Created taxonomy: {taxonomy_file_id}")

// Fetch the latest version of the agent to red team
const agentVersion = await project.agents.get(agentName);

// Define the agent target for taxonomy generation
const target = {
  type: "azure_ai_agent",
  name: agentName,
  version: agentVersion.versions.latest.version,
};

// Create taxonomy for the prohibited actions risk category
// `name` and `version` are required by the EvaluationTaxonomy type at
// compile time, even though the service infers them from the request URL.
const taxonomy = await project.beta.evaluationTaxonomies.create(
  agentName,
  {
    name: agentName,
    version: "1",
    description: "Taxonomy for red teaming run",
    taxonomyInput: {
      type: "agent",
      riskCategories: ["ProhibitedActions"],
      target: target,
    },
  },
);
const taxonomyFileId = taxonomy.id;
console.log(`Created taxonomy: ${taxonomyFileId}`);

Справочник: evaluationTaxonomies.create

curl --request PUT \
  --url 'https://{{account}}.services.ai.azure.com/api/projects/{{project}}/evaluationtaxonomies/{{name}}?api-version=2025-11-15-preview' \
  --header 'authorization: Bearer <token>' \
  --header 'content-type: application/json' \
  --data '{
  "taxonomyInput": {
    "type": "agent",
    "target": {
      "type": "azure_ai_agent",
      "name": "transmitter",
      "version": "1",
      "tool_descriptions": [
        {
          "name": "Dragon APIs",
          "description": "APIs to get information from local RAG applications"
        }
      ]
    },
    "riskCategories": [
      "ProhibitedActions"
    ]
  }
}'

# Create a red team run with attack strategies
eval_run = client.evals.runs.create(
    eval_id=red_team.id,
    name="Red Team Agent Safety Eval Run",
    data_source={
        "type": "azure_ai_red_team",
        "item_generation_params": {
            "type": "red_team_taxonomy",
            "attack_strategies": ["Flip", "Base64", "IndirectJailbreak"],
            "num_turns": 5,
            "source": {"type": "file_id", "id": taxonomy_file_id},
        },
        "target": target.as_dict(),
    },
)
print(f"Created run: {eval_run.id}, status: {eval_run.status}")

// Create a red team run with attack strategies
const evalRun = await openAIClient.evals.runs.create(redTeam.id, {
  name: "Red Team Agent Safety Eval Run",
  data_source: {
    type: "azure_ai_red_team",
    item_generation_params: {
      type: "red_team_taxonomy",
      attack_strategies: ["Flip", "Base64", "IndirectJailbreak"],
      num_turns: 5,
      source: { type: "file_id", id: taxonomyFileId },
    },
    target: target,
  },
});
console.log(`Created run: ${evalRun.id}, status: ${evalRun.status}`);

curl --request POST \
  --url 'https://{{account}}.services.ai.azure.com/api/projects/{{project}}/openai/evals/{{red_team_id}}/runs?api-version=2025-11-15-preview' \
  --header 'authorization: Bearer <token>' \
  --header 'content-type: application/json' \
  --data '{
  "name": "Red Team Agent Run 1",
  "data_source": {
    "type": "azure_ai_red_team",
    "item_generation_params": {
      "type": "red_team_taxonomy",
      "attack_strategies": [
        "Flip",
        "Base64",
        "IndirectJailbreak"
      ],
      "num_turns": 5,
      "source": {
        "type": "file_id",
        "id": "azureai://accounts/{{account}}/projects/{{project}}/evaluationtaxonomies/{{taxonomy_name}}/versions/{{version}}"
      }
    },
    "target": {
      "type": "azure_ai_agent",
      "name": "grok-bird",
      "version": "1",
      "tool_descriptions": [
        {
          "name": "Dragon APIs",
          "description": "APIs to get information from local RAG applications"
        }
      ]
    }
  }
}'

import time

# Poll for run completion
while True:
    run = client.evals.runs.retrieve(run_id=eval_run.id, eval_id=red_team.id)
    print(f"Status: {run.status}")
    if run.status in ("completed", "failed", "canceled"):
        break
    time.sleep(5)

// Poll for run completion
let run = evalRun;
while (!["completed", "failed", "canceled"].includes(run.status)) {
  run = await openAIClient.evals.runs.retrieve(run.id, {
    eval_id: redTeam.id,
  });
  console.log(`Status: ${run.status}`);
  await new Promise((resolve) => setTimeout(resolve, 5000));
}

curl --request GET \
  --url 'https://{{account}}.services.ai.azure.com/api/projects/{{project}}/openai/evals/{{red_team_id}}/runs/{{eval_run_id}}?api-version=2025-11-15-preview' \
  --header 'authorization: Bearer <token>'

print("[Run] Fetching output items...")
items = list(client.evals.runs.output_items.list(run_id=run.id, eval_id=red_team.id))
output_path = os.path.join(data_folder, f"redteam_eval_output_items_{agent_name}.json")
with open(output_path, "w") as f:
    f.write(json.dumps(_to_json_primitive(items), indent=2))
print(f"[Run] Done. Status={run.status}. Output items saved to {output_path}")

import path from "path";
import fs from "node:fs/promises";

console.log("[Run] Fetching output items...");
const items = [];
for await (const item of openAIClient.evals.runs.outputItems.list(run.id, {
  eval_id: redTeam.id,
})) {
  items.push(item);
}

const dataFolder = "./data_folder";
await fs.mkdir(dataFolder, { recursive: true });
const outputPath = path.join(
  dataFolder,
  `redteam_eval_output_items_${agentName}.json`,
);
await fs.writeFile(outputPath, JSON.stringify(items, null, 2));
console.log(
  `[Run] Done. Status=${run.status}. Output items saved to ${outputPath}`,
);

curl --request GET \
  --url 'https://{{account}}.services.ai.azure.com/api/projects/{{project}}/openai/evals/{{red_team_id}}/runs/{{eval_run_id}}/output_items?api-version=2025-11-15-preview' \
  --header 'authorization: Bearer <token>'