Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Apsaugos mechanizmai „Mistral“ agentams

Paskaita 4 iš 12 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Autonominiai agentai ir jų saugumas
  2. Apsaugos mechanizmai pokalbyje
  3. Apsaugos mechanizmai agente
  4. Blokuojamų veiksmų tvarkymas daugiapakopėje sąveikoje
  5. Agentai su įrankiais: ko apsaugos mechanizmai nemato
  6. Rekomenduojama agentų architektūra gamyboje
  7. Pokalbių užbaigimas, pokalbis ar agentas: santrauka
  8. Svarbiausi punktai

Pamoka perrašyta 2026 m. lapkričio 3 d. Ankstesnė versija rėmėsi išgalvotu apsaugos mechanizmo formatu (enabled, kategorijos hate, violence, unpredictable), neegzistuojančiu conversation.send() metodu ir klaidingai teigė, kad apsaugos mechanizmai moderuoja įrankių argumentus. Pagal dokumentaciją jie moderuoja tik įvestį. Kodas dabar atitinka tikrąjį „Conversations API“ (start, append) ir buvo patikrintas naudojant mistralai SDK tipų 3.7.0 versiją. Šaltiniai: Moderavimas ir apsaugos mechanizmai · Agentai ir pokalbiai · „mistralai“ Python SDK.

Autonominiai agentai ir jų saugumas

Agentas kelia didesnę riziką nei paprastas pokalbių robotas: jis kviečia įrankius, naršo internete ir jungia veiksmus į grandines. Apsaugos mechanizmai dengia tik dalį šio paviršiaus – būtent įvestį. Būtent todėl turi tiksliai žinoti, kur juos įdiegti ir ką jie palieka neapsaugotą.

Šioje pamokoje pridėsi apsaugos mechanizmus pokalbiui, tada agentui, tvarkysi jų blokuojamus veiksmus daugiapakopėje sąveikoje ir pamatysi, ką dar turi pridėti, kad įrankiai būtų saugūs.

import json
import os

from mistralai.client import Mistral, errors
from mistralai.client.models import GuardrailConfigTypedDict

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

Apsaugos mechanizmai pokalbyje

„Conversations API“ istoriją saugo serveryje. Pradedi naudodamas client.beta.conversations.start(), kuris priima parametrą guardrails:

GUARDRAILS_RH: list[GuardrailConfigTypedDict] = [
    {
        "block_on_error": True,
        "moderation_llm_v2": {
            "custom_category_thresholds": {
                "sexual": 0.1,
                "hate_and_discrimination": 0.1,
                "violence_and_threats": 0.2,
                "pii": 0.15,
                "jailbreaking": 0.1,
            },
            "action": "block",
        },
    }
]

conversation = client.beta.conversations.start(
    model="mistral-large-latest",
    instructions="You are a professional HR assistant.",
    inputs="What leave options are available?",
    guardrails=GUARDRAILS_RH,
)
print(conversation.conversation_id)

Toliau tęsi naudodamas client.beta.conversations.append(). Šis metodas SDK 3.7.0 versijoje nepriima parametro guardrails, o dokumentacijoje nenurodyta, ar paleidimo metu nustatyti mechanizmai galioja vėlesniems pranešimams. Negrįsk saugumo prielaidomis: jei kiekvienas žingsnis turi būti filtruojamas, naudok agentą, kurio apsaugos mechanizmai paveldimi visuose jo pokalbiuose.

Apsaugos mechanizmai agente

„Mistral“ agentas yra registruota konfigūracija: modelis, instrukcijos, įrankiai ir apsaugos mechanizmai. Saugumo politika tampa agento atributu, o ne kodavimo konvencija.

agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="Customer Support Agent",
    description="Secure customer support agent",
    instructions=(
        "You are a customer support agent. Strict rules: "
        "never disclose personal information; "
        "do not give medical or legal advice; "
        "redirect to a human if the topic is sensitive."
    ),
    guardrails=[
        {
            "block_on_error": True,
            "moderation_llm_v2": {
                "custom_category_thresholds": {
                    "sexual": 0.1,
                    "hate_and_discrimination": 0.1,
                    "violence_and_threats": 0.15,
                    "dangerous": 0.1,
                    "criminal": 0.1,
                    "selfharm": 0.1,
                    "health": 0.3,
                    "financial": 0.3,
                    "law": 0.3,
                    "pii": 0.15,
                    "jailbreaking": 0.1,
                },
                "action": "block",
            },
        }
    ],
)
print(f"Agent created: {agent.id}")

Atkreipk dėmesį į instrukcijų ir slenksčių nuoseklumą: instrukcijos draudžia teikti medicininius ar teisinius patarimus, o health ir law slenksčiai blokuoja tokio tipo užklausas dar prieš modelį jas perskaitant. Instrukcijos įtikinėja; apsaugos mechanizmai riboja.

Pagal dokumentaciją, visi pokalbiai, naudojantys šį agentą, paveldi jo apsaugos mechanizmus be poreikio juos kartoti:

conv = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="How can I return a product?",
)

Pokalbio užklausa taip pat gali perrašyti agento apsaugos mechanizmus, perdavus savo guardrails metodui start(). Norėdamas politiką pakeisti visam laikui, atnaujink agentą naudodamas client.beta.agents.update(agent_id=agent.id, guardrails=[...]).

Blokuojamų veiksmų tvarkymas daugiapakopėje sąveikoje

Užblokuotas pranešimas išmeta errors.SDKError su būsenos kodu 403, o kūnas nurodo pažeistas kategorijas. Pokalbyje blokas nesunaikina sąveikos: mandagiai atsakai, ir vartotojas gali tęsti.

MESSAGE_REFUS = "I cannot process this request. It violates our security policy."


def texte_reponse(reponse) -> str:
    """Text of the last assistant message in a conversation response."""
    for entree in reversed(reponse.outputs):
        if entree.type == "message.output" and isinstance(entree.content, str):
            return entree.content
    return ""


def envoyer(conversation_id: str, message: str) -> str:
    """Adds a message to a conversation and handles a guardrail block."""
    try:
        reponse = client.beta.conversations.append(conversation_id=conversation_id, inputs=message)
    except errors.SDKError as e:
        if e.status_code == 403:
            decisions = json.loads(e.body)["guardrails"]["results"]["moderation_llm_v2"]["decisions"]
            print("Blocked:", [nom for nom, d in decisions.items() if d["violated"]])
            return MESSAGE_REFUS
        raise
    return texte_reponse(reponse)


print(envoyer(conv.conversation_id, "Give me the personal addresses of employees"))

Kai užklausa praeina, pokalbio atsakyme taip pat yra laukas guardrails su kiekvienos kategorijos balais (reponse.guardrails). Registruok juos: jie parodo, ar tavo slenksčiai sureguliuoti tinkamai.

Agentai su įrankiais: ko apsaugos mechanizmai nemato

Agentas, kviečiantis įrankius, atveria antrą atakos paviršių: argumentus, kuriuos modelis perduoda tiems įrankiams, ir jų grąžinamus rezultatus. Apsaugos mechanizmai moderuoja tik gaunamą žinutę; jie netikrina nei šių argumentų, nei rezultatų. Tavo kodas turi tai padaryti.

agent_avec_outils = client.beta.agents.create(
    model="mistral-large-latest",
    name="Support Agent with Tools",
    instructions="Support assistant with access to commands.",
    tools=[
        {
            "type": "function",
            "function": {
                "name": "rechercher_commande",
                "description": "Searches for an order by its number",
                "parameters": {
                    "type": "object",
                    "properties": {"order_id": {"type": "string", "description": "Order number"}},
                    "required": ["order_id"],
                },
            },
        }
    ],
    guardrails=[
        {
            "block_on_error": True,
            "moderation_llm_v2": {
                "custom_category_thresholds": {"pii": 0.15, "jailbreaking": 0.1, "criminal": 0.1},
                "action": "block",
            },
        }
    ],
)

Tokiu būdu deklaruotos funkcijos vykdomos tavo kode: API atsiunčia tau kvietimą ir jo argumentus, tu vykdai funkciją ir grąžini rezultatą. Būtent čia turi patvirtinti argumentus prieš imdamasis veiksmų.

import re

FORMAT_COMMANDE = re.compile(r"CMD-\d{6}")
base_commandes: dict[str, dict] = {}  # your data access


def rechercher_commande(order_id: str, client_connecte: str) -> dict:
    """Executes the tool after validating its arguments."""
    if not FORMAT_COMMANDE.fullmatch(order_id):
        return {"error": "Invalid order number."}
    commande = base_commandes.get(order_id)
    if commande is None or commande["client"] != client_connecte:
        return {"error": "Order not found."}  # never another client's order
    return {"status": commande["status"]}

Prieigos kontrolė – šiuo atveju „ar užsakymas priklauso prisijungusiam klientui?“ – gali kilti tik iš tavo programos: joks klasifikatorius nežino tavo klientų. Tekstui, kurį agentas grąžina vartotojui, pridėk išvesties moderavimą iš kitos pamokos.

Rekomenduojama agentų architektūra gamyboje

Gamyboje apgaubk agentą klase, kuri centralizuoja pokalbio pradėjimą, žinučių siuntimą ir blokavimų skaičiavimą. Staigus 403 šuolis signalizuoja arba apie ataką, arba apie netinkamai sureguliuotą slenkstį, ir tai nori matyti nesikapstant žurnaluose.

class AgentSecurise:
    """Mistral Agent with guardrail block tracking."""

    def __init__(self, client: Mistral, agent_id: str):
        self.client = client
        self.agent_id = agent_id
        self.blocages = 0

    def _bloque(self, e: errors.SDKError) -> dict:
        self.blocages += 1
        decisions = json.loads(e.body)["guardrails"]["results"]["moderation_llm_v2"]["decisions"]
        return {
            "status": "blocked",
            "content": "Request blocked by security policy.",
            "categories": [nom for nom, d in decisions.items() if d["violated"]],
            "blocages_total": self.blocages,
        }

    def demarrer(self, message: str) -> dict:
        """Starts a conversation with the agent."""
        try:
            reponse = self.client.beta.conversations.start(agent_id=self.agent_id, inputs=message)
        except errors.SDKError as e:
            if e.status_code == 403:
                return self._bloque(e)
            raise
        return {
            "status": "ok",
            "conversation_id": reponse.conversation_id,
            "content": texte_reponse(reponse),
            "guardrails": reponse.guardrails,
        }

    def envoyer(self, conversation_id: str, message: str) -> dict:
        """Continues an existing conversation."""
        try:
            reponse = self.client.beta.conversations.append(conversation_id=conversation_id, inputs=message)
        except errors.SDKError as e:
            if e.status_code == 403:
                return self._bloque(e)
            raise
        return {"status": "ok", "content": texte_reponse(reponse), "guardrails": reponse.guardrails}

Pokalbių užbaigimas, pokalbis ar agentas: santrauka

AspektasPokalbių užbaigimas (Chat Completions)Pokalbis (Conversation)Agentas
Kur deklaruojami apsaugos mechanizmaiKviestant kiekvieną kartąconversations.start()agents.create() arba agents.update()
PaveldėjimasNėraNėra dokumentuota append() atvejuVisi agento pokalbiai
Balai atsakyme (SDK 3.7.0)Nepateikiamireponse.guardrailsreponse.guardrails
ĮrankiaiTavo funkcijosTavo funkcijosTavo funkcijos ir integruoti įrankiai
NaudojimasPrototipų kūrimasVienkartinis pokalbisGamyba

Svarbiausi punktai

  • Pokalbis gauna apsaugos mechanizmus paleidimo metu; append() jų nepriima, o jų išlikimas per kelis žingsnius nėra dokumentuotas
  • Agentas perduoda savo apsaugos mechanizmus visiems savo pokalbiams; užklausa gali juos perrašyti
  • Blokas išmeta errors.SDKError (būsena 403): atsakyk mandagiai, pokalbis tęsiasi
  • Apsaugos mechanizmai nemato nei įrankių argumentų, nei jų rezultatų: patvirtink juos savo kode
  • Gamyboje naudok agento lygmenį ir pridėk išvesties moderavimą