Intégrer à LangChain

Utilisez Model Armor avec LangChain pour renforcer la sécurité de vos applications d'IA en filtrant de manière proactive les requêtes et les réponses des LLM. Pour éviter les entrées malveillantes, vérifier la sécurité du contenu et appliquer les règles de sécurité de manière cohérente dans vos applications d'IA, ajoutez Model Armor à vos workflows LangChain.

Avant de commencer

Avant d'implémenter le code, suivez les étapes de configuration ci-dessous : Google Cloud

Sélectionnez ou créez un projet, puis activez la facturation.
Activez l'API Model Armor dans votre projet.
Configurez l'authentification à l'aide de gcloud ou en définissant la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS.
Assurez-vous que votre compte de service dispose du rôle Utilisateur Model Armor (roles/modelarmor.user). Pour gérer les modèles, vous devez disposer du rôle Administrateur Model Armor(roles/modelarmor.admin).
Créez des modèles dans la console Google Cloud .

Exécutables

Pour utiliser Model Armor avec LangChain, vous avez besoin de deux exécutables principaux qui s'intègrent à l'interface LangChain standard.

ModelArmorSanitizePromptRunnable : ce composant examine les saisies utilisateur (requêtes) avant qu'elles n'atteignent le LLM. Il détecte les entrées malveillantes ou les cas de non-respect des règles.
ModelArmorSanitizeResponseRunnable : ce composant filtre la sortie générée par le LLM avant qu'elle ne soit renvoyée à l'utilisateur. Les modifications apportées par l'utilisateur à la réponse après le contrôle de sécurité principal ne sont pas filtrées et vous parviendront à l'état brut.

Installer les packages Python requis

Installez les packages Python suivants :

langchain-google-community version 3.0.4 ou ultérieure
langchain-google-genai

pip install langchain-google-community langchain-google-genai

Schémas d'utilisation

Vous pouvez utiliser Model Armor avec LangChain en effectuant un chaînage de base ou en utilisant un middleware.

Chaîne de base

La méthode la plus courante pour utiliser Model Armor consiste à enchaîner le désinfectant de requêtes, le modèle et le désinfectant de réponses à l'aide de l'opérateur de canalisation LangChain Expression Language (LCEL).

from langchain_google_community.model_armor import (
    ModelArmorSanitizePromptRunnable,
    ModelArmorSanitizeResponseRunnable,
)
from langchain_google_genai import ChatGoogleGenerativeAI

# Initialize Model Armor runnables
sanitize_prompt = ModelArmorSanitizePromptRunnable(
    project="PROJECT_ID",
    location="LOCATION",
    template_id="TEMPLATE_ID",
    fail_open="SANITIZE_PROMPT_ERROR_HANDLING"
)

sanitize_response = ModelArmorSanitizeResponseRunnable(
    project="PROJECT_ID",
    location="LOCATION",
    template_id="TEMPLATE_ID",
    fail_open="SANITIZE_RESPONSE_ERROR_HANDLING"
)

# Initialize the model
llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash", <var>...</var>)

# Build the chain
chain = sanitize_prompt | llm | sanitize_response

# Invoke
try:
    result = chain.invoke("<var>YOUR_USER_PROMPT_HERE</var>")
    print(result)
except ValueError as e:
    print(f"Content blocked: {e}")

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud .
LOCATION : emplacement du modèle.
TEMPLATE_ID : ID du modèle Model Armor créé dans la section Avant de commencer.
SANITIZE_PROMPT_ERROR_HANDLING : valeur booléenne qui contrôle la gestion des exceptions pour ModelArmorSanitizePromptRunnable, True ou False.
SANITIZE_RESPONSE_ERROR_HANDLING : valeur booléenne qui contrôle la gestion des exceptions pour ModelArmorSanitizeResponseRunnable, True ou False.

Lors du traitement des erreurs, Model Armor se comporte comme suit :
- True : consigne un avertissement, mais laisse passer le contenu même si des risques sont détectés.
- False : génère une ValueError et bloque l'exécution lorsque du contenu dangereux est détecté.

Middleware pour les agents

Pour les agents LangChain qui utilisent des outils, vous pouvez utiliser ModelArmorMiddleware. Ce middleware applique le sanitizer runnable approprié à différents points d'interaction que l'agent LangChain traverse lorsqu'il utilise des outils.

from langchain.agents import create_agent
from langchain.tools import tool
from langchain_google_genai import ChatGoogleGenerativeAI

from langchain_google_community.model_armor import (
    ModelArmorMiddleware,
    ModelArmorSanitizePromptRunnable,
    ModelArmorSanitizeResponseRunnable,
)

# Create Model Armor sanitizers (same configuration as earlier sections)
prompt_sanitizer = ModelArmorSanitizePromptRunnable(
    project="PROJECT_ID",
    location="LOCATION",
    template_id="TEMPLATE_ID",
    fail_open="SANITIZE_PROMPT_ERROR_HANDLING",
)

response_sanitizer = ModelArmorSanitizeResponseRunnable(
    project="PROJECT_ID",
    location="LOCATION",
    template_id="TEMPLATE_ID",
    fail_open="SANITIZE_RESPONSE_ERROR_HANDLING",
)

# Wrap them in the official Model Armor middleware
model_armor_middleware = ModelArmorMiddleware(
    prompt_sanitizer=prompt_sanitizer,
    response_sanitizer=response_sanitizer,
)

# --- Create agent with Model Armor middleware ---
agent = create_agent(
    model="SOME_GEMINI_VERSION",
    tools=[],
    middleware=[model_armor_middleware],
)

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud .
LOCATION : emplacement du modèle.
TEMPLATE_ID : ID du modèle Model Armor créé dans la section Avant de commencer.
SANITIZE_PROMPT_ERROR_HANDLING : valeur booléenne qui contrôle la gestion des exceptions pour ModelArmorSanitizePromptRunnable, True ou False.
SANITIZE_RESPONSE_ERROR_HANDLING : valeur booléenne qui contrôle la gestion des exceptions pour ModelArmorSanitizeResponseRunnable, True ou False.

Lors du traitement des erreurs, Model Armor se comporte comme suit :
- True : consigne un avertissement, mais laisse passer le contenu même si des risques sont détectés.
- False : génère une ValueError et bloque l'exécution lorsque du contenu dangereux est détecté.

Cette configuration permet de s'assurer que les entrées et les sorties sont filtrées, même lorsque l'agent exécute un raisonnement ou une utilisation d'outil en plusieurs étapes.

Examen des documents

Vous pouvez utiliser les exécutables Model Armor pour examiner les documents importés avant de les traiter. C'est essentiel pour les workflows tels que la synthèse, où le document source peut contenir du contenu malveillant caché. Vous pouvez charger le contenu du fichier et le transmettre via ModelArmorSanitizePromptRunnable avant de l'envoyer au LLM.

Gestion des événements personnalisés

Pour l'observabilité, les exécutables envoient un événement on_model_armor_finding lorsque du contenu non sécurisé est détecté. Vous pouvez associer un gestionnaire de rappel personnalisé pour enregistrer des détails spécifiques (tels que les résultats et le contenu) ou déclencher des alertes sans planter le flux de l'application.

from langchain_core.callbacks import BaseCallbackHandler

class SecurityHandler(BaseCallbackHandler):
    def on_custom_event(self, name, data, **kwargs):
        if name == "on_model_armor_finding":
            print(f"Alert: {data['findings']} detected in {data['template_id']}")

# Attach to config
chain.invoke(user_input, config={"callbacks": [SecurityHandler()]})