Automatisation par IA : Construire des applications LLM – Guide pratique pour les ingénieurs
Bonjour à tous, Alex Petrov ici. Je suis ingénieur ML et je construis avec des Modèles de Langage de Grande Taille (LLM) depuis leurs débuts. L’enthousiasme est réel, mais le potentiel pour une automatisation IA pratique et impactante l’est tout autant. Ce guide est destiné aux ingénieurs qui souhaitent aller au-delà des tutoriels et commencer à construire de réelles applications LLM. Nous aborderons les concepts clés, les outils pratiques et les étapes actionnables pour lancer vos projets d’automatisation LLM.
L’objectif n’est pas seulement de parler des LLM, mais de vous montrer comment les intégrer dans vos flux de travail pour des bénéfices tangibles. Nous parlons d’automatisation de tâches, de création d’agents intelligents et d’amélioration des systèmes existants grâce à la puissance du traitement du langage naturel. Il s’agit d’une automatisation IA pratique : construire des applications LLM qui résolvent des problèmes réels.
Comprendre les LLM pour l’automatisation
Avant d’explorer le code, définissons brièvement ce qu’est un LLM dans le contexte de l’automatisation. Un LLM est un puissant modèle statistique entraîné sur de vastes quantités de données textuelles. Il apprend des motifs, de la grammaire et même certaines connaissances du monde. Cela lui permet de générer du texte semblable à celui des humains, de répondre à des questions, de résumer des documents, de traduire des langues et bien plus encore.
Pour l’automatisation, nous n’utilisons pas seulement les LLM pour la conversation. Nous exploitons leur capacité à comprendre et à générer du texte pour interagir avec d’autres systèmes, traiter des données non structurées et prendre des décisions. Pensez à un LLM comme à un moteur de traitement et de génération de texte très capable que vous pouvez contrôler de manière programmatique.
Composants clés d’une application LLM
Chaque application LLM, quelle que soit sa complexité, implique généralement quelques composants clés :
* **Le LLM lui-même :** C’est le cerveau de votre application. Vous interagirez avec lui via une API (par exemple, OpenAI, Anthropic, Google Gemini, modèles open-source hébergés localement).
* **Ingénierie des invites :** C’est l’art et la science de formuler des entrées efficaces (invites) pour guider le comportement du LLM. Une bonne invite est cruciale pour obtenir la sortie désirée.
* **Gestion des entrées/sorties :** Comment vous fournissez des données au LLM et comment vous traitez ses réponses. Cela implique souvent de parser du texte, de convertir des formats de données et d’interagir avec d’autres API ou bases de données.
* **Logique d’orchestration/agence :** Pour des applications plus complexes, vous aurez besoin de logique pour enchaîner plusieurs appels LLM, utiliser des outils, prendre des décisions basées sur les sorties LLM, et gérer l’état.
* **Gestion des données :** Stocker et récupérer des informations pertinentes pour votre application. Cela pourrait être des données utilisateur, des conversations précédentes ou des bases de connaissances externes.
Choisir votre LLM : Propriétaire vs Open Source
C’est une décision critique lorsque vous souhaitez construire des applications LLM.
**Modèles propriétaires (par exemple, GPT-4, Claude 3, Gemini Ultra) :**
* **Avantages :** Performance généralement supérieure, plus facile à utiliser (appels API), mises à jour constantes, solide soutien communautaire.
* **Inconvénients :** Coût (par token), préoccupations en matière de confidentialité des données (bien que les fournisseurs offrent des solutions d’entreprise), manque de contrôle total sur le modèle, dépendance au fournisseur.
* **Quand les utiliser :** Prototypage rapide, applications à enjeux élevés nécessitant des performances optimales, lorsque vous n’avez pas l’infrastructure pour héberger les modèles.
**Modèles open-source (par exemple, Llama 3, Mistral, Mixtral) :**
* **Avantages :** Pas de coût par token (une fois hébergé), contrôle total, potentiel de fine-tuning, meilleure confidentialité des données (vous contrôlez les données), pas de dépendance au fournisseur.
* **Inconvénients :** Nécessite une infrastructure pour l’hébergement (GPUs), déploiement plus complexe, performance variable, moins de finition « prête à l’emploi ».
* **Quand les utiliser :** Applications sensibles au coût, exigences strictes en matière de confidentialité des données, lorsque vous devez peaufiner pour des tâches spécifiques, lorsque vous disposez des ressources informatiques.
Pour commencer, je recommande de commencer avec un modèle propriétaire comme la série GPT d’OpenAI ou Claude d’Anthropic. La facilité d’utilisation vous permettra de vous concentrer sur la logique de votre application plutôt que sur l’infrastructure. Une fois que vous comprenez les motifs, vous pouvez explorer des alternatives open-source.
Outils pratiques pour construire des applications LLM
Voici les outils que j’utilise régulièrement pour l’automatisation IA : construire des applications LLM de manière efficace.
* **Python :** Le langage par défaut pour l’ingénierie ML. La plupart des bibliothèques et frameworks LLM sont d’abord conçus pour Python.
* **SDK des fournisseurs de LLM :** `openai` (pour les modèles OpenAI), `anthropic` (pour Claude), `google-generativeai` (pour Gemini). Ceux-ci fournissent un accès direct à l’API.
* **LangChain / LlamaIndex :** Ce sont des frameworks d’orchestration puissants.
* **LangChain :** Excellent pour construire des agents multi-étapes, enchaîner des appels LLM, intégrer des outils (APIs, bases de données) et gérer la mémoire conversationnelle. Il fournit des abstractions pour les invites, les modèles, les parseurs de sortie et les agents.
* **LlamaIndex :** Se concentre sur l’ingestion de données, l’indexation et la récupération. Il est idéal lorsque votre LLM doit interagir avec une grande base de connaissances externe (vos documents, bases de données, etc.). Il vous aide à construire des systèmes RAG (Retrieval Augmented Generation) de manière efficace.
* **Bases de données vectorielles (par exemple, Pinecone, Chroma, Weaviate, Qdrant) :** Essentielles pour RAG. Elles stockent des embeddings vectoriels de vos données, permettant une recherche sémantique rapide. Lorsqu’un utilisateur pose une question, vous recherchez dans votre base de données vectorielle des morceaux d’information pertinents, puis vous transmettez ces morceaux au LLM accompagné de la question de l’utilisateur.
* **FastAPI / Flask :** Pour construire des APIs web afin d’exposer votre application LLM.
* **Streamlit / Gradio :** Pour construire rapidement des interfaces utilisateur interactives pour vos applications LLM. Idéales pour les démos et les outils internes.
* **Docker :** Pour empaqueter et déployer vos applications de manière cohérente.
Étape par étape : Construire votre première application d’automatisation LLM
Passons à la construction d’une application LLM simple mais pratique : un système intelligent de résumé de documents et de questions-réponses pour des documents internes de l’entreprise. C’est un exemple classique d’automatisation IA : construire des applications LLM pour améliorer la productivité.
**Objectif :** Permettre aux utilisateurs de télécharger un document PDF, puis de poser des questions sur son contenu ou de demander un résumé.
**Technologies :** Python, OpenAI API, LangChain, ChromaDB (pour la simplicité), FastAPI.
**1. Configurez votre environnement :**
« `bash
python -m venv venv
source venv/bin/activate # Sur Windows : .\venv\Scripts\activate
pip install openai langchain chromadb pypdf fastapi uvicorn python-dotenv
« `
Créez un fichier `.env` dans la racine de votre projet pour votre clé API :
« `
OPENAI_API_KEY=« votre_clé_api_openai_ici »
« `
**2. Traitement et embedding des documents (Fondation RAG) :**
Nous devons charger le document, le diviser en morceaux gérables et créer des embeddings pour chaque morceau. Ces embeddings seront stockés dans une base de données vectorielle (ChromaDB dans ce cas).
« `python
# app.py
import os
from dotenv import load_dotenv
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
load_dotenv()
os.environ[« OPENAI_API_KEY »] = os.getenv(« OPENAI_API_KEY »)
def process_document(file_path: str):
«««Charge un PDF, le divise et stocke les embeddings dans ChromaDB.»»«
loader = PyPDFLoader(file_path)
documents = loader.load()
text_splitter = RecursiveCharacterTextTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = text_splitter.split_documents(documents)
embeddings = OpenAIEmbeddings()
vector_store = Chroma.from_documents(chunks, embeddings, persist_directory=« ./chroma_db »)
vector_store.persist()
print(f« Traité {len(chunks)} morceaux et stockés dans ChromaDB. »)
return vector_store
# Exemple d’utilisation (vous intégrez cela dans un point de terminaison de téléchargement)
# if __name__ == « __main__ » :
# # Créez un PDF factice pour tester si vous n’en avez pas un
# # avec open(« example.pdf », « w ») as f :
# # f.write(« Ceci est un document d’exemple sur les politiques de l’entreprise. » * 100)
# process_document(« example.pdf »)
« `
**Explication :**
* `PyPDFLoader` : Lit le contenu d’un PDF.
* `RecursiveCharacterTextTextSplitter` : Divise le document en morceaux plus petits et qui se chevauchent. Le chevauchement aide à maintenir le contexte entre les morceaux.
* `OpenAIEmbeddings` : Convertit les morceaux de texte en vecteurs numériques (embeddings) en utilisant le modèle d’embedding d’OpenAI.
* `Chroma.from_documents` : Crée une instance de ChromaDB, calcule les embeddings pour les morceaux et les stocke. `persist_directory` sauvegarde la base de données sur le disque.
**3. Construction de la logique de l’application LLM (Q&A et Résumé) :**
Maintenant, nous allons utiliser LangChain pour interagir avec le LLM et la base de données vectorielle.
« `python
# app.py (suite)
from langchain.chat_models import ChatOpenAI
from langchain.chains import RetrievalQA, create_qa_with_sources_chain
from langchain.prompts import ChatPromptTemplate
def get_qa_chain(vector_store: Chroma):
«««Crée une chaîne RetrievalQA pour la réponse aux questions.»»«
llm = ChatOpenAI(model_name=« gpt-3.5-turbo », temperature=0.7)
# Invite personnalisée pour Q&A
qa_template = «««
Vous êtes un assistant IA pour répondre aux questions sur les documents de l’entreprise.
Utilisez le contexte suivant pour répondre à la question.
Si vous ne connaissez pas la réponse, dites simplement que vous ne savez pas, n’essayez pas d’inventer une réponse.
Contexte : {context}
Question : {question}
Réponse :
“””
qa_prompt = ChatPromptTemplate.from_template(qa_template)
# La chaîne RetrievalQA combine récupération et génération
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type=”stuff”, # ‘stuff’ intègre tous les documents récupérés dans l’invite
retriever=vector_store.as_retriever(),
return_source_documents=True,
chain_type_kwargs={“prompt”: qa_prompt}
)
return qa_chain
def get_summarization_chain(vector_store: Chroma):
“””Crée une chaîne de résumé.”””
llm = ChatOpenAI(model_name=”gpt-3.5-turbo”, temperature=0.5)
# Invite personnalisée pour le résumé
summary_template = “””
Vous êtes un assistant IA chargé de résumer des documents.
Fournissez un résumé concis du contexte suivant.
Contexte : {context}
Résumé :
“””
summary_prompt = ChatPromptTemplate.from_template(summary_template)
# Pour le résumé, nous pourrions simplement récupérer les N premières sections
# et les transmettre directement à l’LLM avec une invite de résumé.
# Une approche plus simple pour le résumé de document unique pourrait consister à obtenir tous les docs
# ou à utiliser une chaîne map_reduce pour des documents très longs.
# Pour cet exemple, prenons simplement les 5 premières sections pertinentes pour un résumé général.
# Nous adapterons RetrievalQA pour agir comme un résumeur en modifiant l’invite
summarizer_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type=”stuff”,
retriever=vector_store.as_retriever(search_kwargs={“k”: 5}), # Récupérer les 5 premières sections
return_source_documents=False,
chain_type_kwargs={“prompt”: summary_prompt}
)
return summarizer_chain
“`
**Explication :**
* `ChatOpenAI` : Notre interface LLM.
* `RetrievalQA.from_chain_type` : C’est un composant central de LangChain pour RAG. Il prend un récupérateur (notre `vector_store.as_retriever()`) pour trouver des documents pertinents et un LLM pour générer la réponse basée sur ces documents.
* `chain_type=”stuff”` : Cela signifie que tous les documents récupérés sont “fourrés” dans l’invite de l’LLM. Pour des documents très longs, vous pourriez utiliser `map_reduce` ou `refine`.
* `ChatPromptTemplate` : Nous permet de définir des invites structurées avec des espaces réservés (`{context}`, `{question}`).
* `get_summarization_chain` : Semblable à Q&A, mais avec une invite différente et potentiellement moins de documents récupérés si nous visons un résumé de haut niveau.
**4. Création de l’API Web FastAPI :**
Cela exposera la fonctionnalité de notre application LLM via des points de terminaison HTTP.
“`python
# app.py (suite)
from fastapi import FastAPI, UploadFile, File, HTTPException
from pydantic import BaseModel
import shutil
app = FastAPI()
# Variable globale pour stocker notre magasin de vecteurs (dans une vraie application, gérez cela mieux)
current_vector_store: Chroma = None
class QueryRequest(BaseModel):
question: str
@app.post(“/upload-document/”)
async def upload_document(file: UploadFile = File(…)):
global current_vector_store
if not file.filename.endswith(“.pdf”):
raise HTTPException(status_code=400, detail=”Seuls les fichiers PDF sont autorisés.”)
file_location = f”temp_{file.filename}”
with open(file_location, “wb+”) as file_object:
shutil.copyfileobj(file.file, file_object)
try:
current_vector_store = process_document(file_location)
return {“message”: f”Document ‘{file.filename}’ traité avec succès.”}
except Exception as e:
raise HTTPException(status_code=500, detail=f”Erreur lors du traitement du document : {e}”)
finally:
os.remove(file_location) # Nettoyer le fichier temporaire
@app.post(“/ask/”)
async def ask_question(request: QueryRequest):
if current_vector_store is None:
raise HTTPException(status_code=400, detail=”Aucun document n’a encore été téléchargé. Veuillez d’abord télécharger un PDF.”)
qa_chain = get_qa_chain(current_vector_store)
result = qa_chain({“query”: request.question})
return {“answer”: result[“result”], “sources”: [doc.metadata for doc in result[“source_documents”]]}
@app.post(“/summarize/”)
async def summarize_document():
if current_vector_store is None:
raise HTTPException(status_code=400, detail=”Aucun document n’a encore été téléchargé. Veuillez d’abord télécharger un PDF.”)
summary_chain = get_summarization_chain(current_vector_store)
# Pour le résumé, nous pourrions simplement passer une requête générique qui déclenche le résumé
result = summary_chain({“query”: “Fournissez un résumé complet du document.”})
return {“summary”: result[“result”]}
if __name__ == “__main__”:
import uvicorn
# Assurez-vous de créer un PDF fictif pour les tests si nécessaire
# with open(“example.pdf”, “w”) as f:
# f.write(“Ceci est un document exemple sur les politiques de l’entreprise. ” * 100)
# process_document(“example.pdf”) # Pré-traitez pour des tests locaux si vous le souhaitez
uvicorn.run(app, host=”0.0.0.0″, port=8000)
“`
**Explication :**
* `FastAPI` : Crée notre serveur web.
* `UploadFile` : Gère les téléchargements de fichiers.
* `/upload-document/` : Point de terminaison pour recevoir un PDF, le traiter et créer/mette à jour le magasin de vecteurs.
* `/ask/` : Point de terminaison pour recevoir une question, interroger le magasin de vecteurs et obtenir une réponse générée par l’LLM.
* `/summarize/` : Point de terminaison pour obtenir un résumé du document téléchargé.
* `current_vector_store` : Un moyen simple de maintenir le magasin de vecteurs actif en mémoire. Pour la production, vous voudriez une solution plus solide (par exemple, chargement depuis le disque au démarrage, utilisation d’une base de données vectorielle persistante).
**5. Exécution et Test de votre Application :**
1. Enregistrez le code sous `app.py`.
2. Créez un fichier `example.pdf` ou utilisez un PDF réel.
3. Exécutez l’application FastAPI : `uvicorn app:app –reload`
4. Ouvrez votre navigateur à `http://127.0.0.1:8000/docs` pour voir l’interface OpenAPI (Swagger UI).
5. Utilisez l’UI pour :
* Téléchargez votre `example.pdf` sur `/upload-document/`.
* Une fois téléchargé, essayez de poser des questions sur `/ask/` (par exemple, “De quoi parle ce document ?”)
* Demandez un résumé sur `/summarize/`.
Ce exemple démontre un flux complet pour l’automatisation IA : créer des applications LLM pour la compréhension de documents.
Concepts Avancés pour l’Automatisation LLM
Une fois que vous maîtrisez les bases, envisagez ces sujets avancés pour rendre vos applications LLM plus solides et puissantes.
**1. Workflows Agence:**
Au lieu de simples Q&A, les agents peuvent réaliser des tâches en plusieurs étapes. Un agent utilise un LLM comme son “moteur de raisonnement” et a accès à des “outils” (par exemple, un moteur de recherche, une calculatrice, une API vers vos systèmes internes, un outil de requête de base de données). L’LLM décide quel outil utiliser, quand et avec quelles entrées, en fonction de la demande de l’utilisateur.
* **Exemple :** Un agent de service client qui peut rechercher dans votre base de connaissances (RAG), vérifier l’état des commandes (outil API), et planifier un rappel (un autre outil API).
* **Frameworks :** Les agents LangChain sont excellents pour cela.
**2. Fine-tuning vs. Ingénierie des Prompts :**
* **Ingénierie des Prompts :** Modifier l’invite d’entrée pour guider le comportement de l’LLM. C’est votre première ligne de défense et souvent suffisante. C’est moins cher et plus rapide.
* **Fine-tuning :** Former un LLM existant sur un ensemble de données plus petit et personnalisé pour adapter son style, son ton, ou ses connaissances factuelles spécifiques. C’est plus coûteux et long, mais peut offrir des gains de performance significatifs pour des tâches hautement spécialisées.
* **Quand faire du fine-tuning :** Lorsque l’ingénierie des prompts ne suffit pas, lorsque vous avez besoin d’un format de sortie très spécifique, ou lorsque vous souhaitez réduire la longueur de l’invite (et donc le coût). Pour l’automatisation IA : créer des applications LLM avec des exigences uniques, le fine-tuning peut être clé.
**3. Analyse et Validation des Sorties :**
Les LLM peuvent parfois “halluciner” ou fournir une sortie dans un format inattendu.
* **Pydantic :** LangChain s’intègre bien avec Pydantic pour une sortie structurée. Vous définissez un modèle Pydantic, et LangChain incitera l’LLM à générer un JSON conforme à ce schéma, puis le parsage.
* **Regex / Parsers Personnalisés :** Pour des cas plus simples, des expressions régulières ou une logique de parsage personnalisée peuvent extraire des informations d’un texte libre.
* **Boucles de Validation :** Si la sortie de l’LLM est critique, vous pourriez mettre en œuvre une boucle où vous validez la sortie et, si elle est incorrecte, la renvoyez à l’LLM avec des instructions pour corriger.
**4. Surveillance et Évaluation :**
* **Journalisation :** Crucial pour le débogage et la compréhension du comportement de l’LLM. Journalisez les invites, les réponses et toute erreur.
* **Métriques :** Suivez la latence, l’utilisation des tokens, et les taux de réussite.
* **Humain dans le Boucle :** Pour une automatisation critique, faites examiner les sorties de l’LLM par un humain avant qu’elles ne soient entièrement automatisées. C’est particulièrement important lors du déploiement initial.
* **Tests A/B :** Expérimentez avec différentes invites, modèles, ou configurations de chaîne pour trouver ce qui fonctionne le mieux.
**5. Optimisation des Coûts :**
L’utilisation de LLM peut être coûteuse.
* **Gestion des Tokens :** Soyez attentif aux nombres de tokens d’entrée et de sortie. Résumez les documents récupérés avant de les transmettre au LLM s’ils sont trop longs.
* **Sélection du Modèle :** Utilisez des modèles plus petits et moins coûteux (par exemple, `gpt-3.5-turbo`) pour des tâches simples et réservez les modèles plus grands pour un raisonnement complexe.
* **Mise en Cache :** Mettez en cache les réponses des LLM pour des requêtes identiques afin d’éviter les appels API redondants.
* **Traitement par Lots :** Si vous avez plusieurs requêtes indépendantes, regroupez-les pour réduire les frais généraux.
Considérations de Sécurité et Éthiques
Lorsque vous automatisez des tâches avec l’IA : créez des applications LLM, ces points sont non négociables.
* **Confidentialité des Données :** Soyez extrêmement vigilant avec les données sensibles. N’envoyez pas d’informations personnellement identifiables (PII) ou de données confidentielles d’entreprise aux API LLM publiques sans anonymisation appropriée ou accords explicites. Envisagez d’héberger vous-même des modèles open-source pour un contrôle maximal.
* **Biais :** Les LLM sont entraînés sur d’immenses ensembles de données qui reflètent des biais sociétaux. Soyez conscient que votre application LLM pourrait en perpétuer ces biais de manière involontaire. Mettez en place des tests et un suivi pour détecter et atténuer les biais.
* **Hallucinations :** Les LLM peuvent générer des informations factuellement incorrectes. Pour des applications critiques, vérifiez toujours les sorties des LLM, surtout si elles impliquent des faits ou des décisions. RAG aide à atténuer cela en ancrant le LLM dans des données spécifiques.
* **Injection de Prompt :** Des utilisateurs malveillants pourraient essayer d’« injecter » des instructions dans vos prompts pour contourner les protections ou amener le LLM à faire des choses inattendues. Concevez vos prompts avec soin et envisagez une désinfection des entrées.
* **Transparence :** Soyez transparent avec les utilisateurs lorsqu’ils interagissent avec un système d’IA.
Avenir de l’Automatisation LLM
Le domaine évolue incroyablement vite. Nous voyons :
* **Multimodalité :** Des LLM capables de traiter et de générer non seulement du texte, mais aussi des images, de l’audio et de la vidéo. Cela ouvre de toutes nouvelles possibilités d’automatisation.
* **Fenêtres de Contexte Plus Longues :** Des modèles capables de gérer des entrées beaucoup plus grandes, réduisant ainsi le besoin de stratégies de découpage et de récupération complexes.
* **Modèles Plus Efficaces :** Des modèles plus petits et plus rapides qui peuvent fonctionner sur du matériel moins puissant, rendant l’automatisation IA plus accessible.
* **Agents Autonomes :** Des LLM capables de planifier, d’exécuter et de s’auto-corriger sur de longues périodes, collaborant avec d’autres agents ou outils pour atteindre des objectifs complexes.
L’opportunité pour l’automatisation IA : créer des applications LLM qui transforment véritablement les flux de travail est immense. Commencez petit, itérez rapidement et continuez à apprendre.
FAQ
**Q1 : Quel est le plus grand défi lorsque l’on essaie d’automatiser des tâches avec l’IA : créer des applications LLM ?**
A1 : Le plus grand défi consiste souvent à passer d’un simple prompt à une application solide prête pour la production. Cela implique de gérer des entrées utilisateur diverses, d’assurer des sorties fiables, d’intégrer des systèmes existants et de gérer les coûts. L’ingénierie de prompt, l’analyse des sorties et la gestion des erreurs sont cruciales pour la fiabilité.
**Q2 : Dois-je me concentrer sur des LLM open-source ou propriétaires pour mon premier projet ?**
A2 : Pour votre premier projet, je recommande de commencer avec un modèle propriétaire comme GPT d’OpenAI ou Claude d’Anthropic. Leurs API sont généralement plus faciles à utiliser, et les modèles sont souvent plus performants immédiatement, vous permettant de vous concentrer sur la logique de votre application sans vous inquiéter de l’infrastructure ou du déploiement du modèle. Une fois que vous comprenez le flux de travail, vous pouvez explorer des options open-source pour des besoins spécifiques.
**Q3 : Comment puis-je m’assurer que mon application LLM fournit des informations précises et évite les « hallucinations » ?**
A3 : La méthode la plus efficace est le Retrieval Augmented Generation (RAG). En fournissant au LLM un contexte spécifique et pertinent provenant de vos propres sources de données fiables (comme dans notre exemple de Q&A document), vous « ancrez » ses réponses. De plus, rédiger des prompts clairs qui instruisent le LLM à n’utiliser que le contexte fourni et à indiquer lorsqu’il ne connaît pas la réponse aide considérablement. Pour des applications critiques, un examen humain des sorties est une bonne pratique.
🕒 Published: