Scénarios d'application verticale des agents IA
Différents domaines ont des exigences et des caractéristiques différentes pour les agents.
Grâce à la personnalisation par domaine, les agents peuvent fournir des services plus professionnels.
Agent de code
Agent de code est l'un des domaines d'application d'agents les plus réussis.
Capable de comprendre les bases de code, d'écrire du nouveau code et de déboguer les problèmes.
Capacités principales
Complétion de code: Prédire le segment de code suivant en fonction du contexte.
Génération de code: Générer du code à partir de descriptions en langage naturel.
Revue de code: Découvrir des problèmes et des améliorations dans le code.
Localisation de bogues: Analyser les messages d'erreur et localiser la cause racine des problèmes.
Refactorisation de code: Proposer et exécuter des suggestions d'optimisation du code.
Systèmes représentatifs
| Système | Entreprise de développement | Fonctionnalités |
|---|---|---|
| GitHub Copilot | GitHub/OpenAI | Principalement la complétion de code, des suggestions en temps réel |
| Claude Code | Anthropic | Assistant en ligne de commande, compréhension approfondie du code |
| Devin | Cognition | Programmation autonome, exécution de tâches de bout en bout |
| Cursor | Cursor | Éditeur de code IA, intégration approfondie à l'IDE |
Exemples d'implémentation de code
Implémentation de l'agent Text2SQL
"""
Agent Text2SQL
Convertir le langage naturel en requêtes SQL
"""
def __init__(self, llm, schema):
self.llm = llm
# Informations sur le schéma de base de données
self.schema = schema
def convert(self, question):
"""
Convertir des problèmes en langage naturel en SQL
:param question: Question en langage naturel
:return: Instruction de requête SQL
"""
prompt = f"""
Vous êtes un expert SQL.
Schéma de base de données :
{self.schema}
Règles :
1. Générer uniquement des requêtes SELECT (INSERT/UPDATE/DELETE ne sont pas pris en charge)
2. Utiliser des alias de table pertinents
3. Ajouter les conditions JOIN nécessaires
4. Utiliser des alias de colonne clairs
Question : {question}
Veuillez générer la requête SQL correspondante.
"""
sql = self.llm.generate(prompt)
# Vérification de sécurité
return self.sanitize(sql)
def sanitize(self, sql):
"""
Vérification de sécurité SQL
S'assurer qu'aucune opération dangereuse n'est incluse
"""
# Vérification des minuscules
sql_lower = sql.lower().strip()
# Vérifier qu'il contient uniquement SELECT
forbidden_keywords = [
"insert", "update", "delete", "drop",
"create", "alter", "truncate", "exec",
"execute", "grant", "revoke"
]
for keyword in forbidden_keywords:
if keyword in sql_lower:
raise ValueError(f"Mots-clés interdits : {keyword}")
return sql
def execute(self, question, db_connection):
"""
Exécuter la requête Text2SQL
"""
sql = self.convert(question)
cursor = db_connection.cursor()
cursor.execute(sql)
results = cursor.fetchall()
columns = [desc[0] for desc in cursor.description]
return {"columns": columns, "rows": results}
Agent d'analyse de données
L'agent d'analyse de données peut comprendre les besoins en matière de données, exécuter des requêtes et générer des rapports d'analyse.
Permet aux utilisateurs non techniques d'effectuer des analyses de données complexes.
Capacités principales
Compréhension des données: Comprendre la structure de la base de données et la signification des données.
Génération de requêtes: Text2SQL, conversion du langage naturel en requêtes.
Visualisation: Générer des suggestions et configurations de graphiques.
Génération de rapports: Analyser les résultats et générer des rapports en langage naturel.
Implémentation du code
Implémentation de l'agent d'analyse de données
"""
Agent d'analyse de données
Comprendre les besoins en données, exécuter l'analyse, générer des rapports
"""
def __init__(self, llm, db_connection, chart_generator):
self.llm = llm
self.db = db_connection
self.chart_generator = chart_generator
def analyze(self, request):
"""
Gérer les demandes d'analyse de données
"""
# Étape 1 : Comprendre les exigences de l'analyse
intent = self.parse_intent(request)
# Étape 2 : Générer la requête
query = self.generate_query(intent)
# Étape 3 : Exécuter la requête
data = self.execute_query(query)
# Étape 4 : Analyser les données
analysis = self.perform_analysis(data, intent)
# Étape 5 : Générer des suggestions de visualisation
charts = self.suggest_charts(analysis)
# Étape 6 : Générer le rapport
report = self.generate_report(analysis, charts)
return {
"intent": intent,
"query": query,
"data": data,
"analysis": analysis,
"charts": charts,
"report": report
}
def parse_intent(self, request):
"""Analyser l'intention de l'utilisateur"""
prompt = f"""
Analysez la requête de données suivante et extrayez les informations clés :
Requête : {request}
Veuillez extraire :
1. Objectif de l'analyse (comparaison, tendance, distribution, etc.)
2. Tables et champs impliqués
3. Plage temporelle (le cas échéant)
4. Conditions de filtre (le cas échéant)
"""
return self.llm.generate(prompt)
def generate_query(self, intent):
"""Générer la requête SQL"""
prompt = f"""
Générez une requête SQL en fonction de l'intention suivante :
{intent}
Schéma de base de données :
{self.get_schema()}
"""
return self.llm.generate(prompt)
def execute_query(self, query):
"""Exécuter la requête"""
cursor = self.db.cursor()
cursor.execute(query)
columns = [desc[0] for desc in cursor.description]
rows = cursor.fetchall()
return {"columns": columns, "rows": rows}
def perform_analysis(self, data, intent):
"""Exécuter l'analyse de données"""
# Implémentation simplifiée
import statistics
rows = data["rows"]
columns = data["columns"]
analysis = {
"row_count": len(rows),
"summary": {}
}
# Calculer les statistiques pour les colonnes numériques
for i, col in enumerate(columns):
if self.is_numeric(rows, i):
values = [row[i] for row in rows if row[i] is not None]
if values:
analysis["summary"][col] = {
"min": min(values),
"max": max(values),
"avg": statistics.mean(values),
"median": statistics.median(values)
}
return analysis
def suggest_charts(self, analysis):
"""Recommander des graphiques de visualisation"""
suggestions = []
# Recommander des graphiques en fonction du type d'analyse
if "trend" in str(analysis).lower():
suggestions.append({
"type": "line",
"description": "Graphique linéaire, adapté pour montrer des tendances"
})
if "comparison" in str(analysis).lower():
suggestions.append({
"type": "bar",
"description": "Diagramme à barres, adapté pour comparer des catégories"
})
suggestions.append({
"type": "table",
"description": "Tableau de données, présentant des données détaillées"
})
return suggestions
def generate_report(self, analysis, charts):
"""Générer un rapport d'analyse"""
prompt = f"""
D'après les résultats d'analyse suivants, générez un rapport en langage naturel :
Résultats de l'analyse :
{analysis}
Graphique recommandé :
{charts}
Veuillez générer un rapport d'analyse clair.
"""
return self.llm.generate(prompt)
Agent de service client
L'agent de service client doit gérer des conversations multi-tours, comprendre l'intention de l'utilisateur et fournir des réponses précises.
C'est l'un des scénarios d'IA les plus largement déployés.
Capacités principales
Reconnaissance d'intention: Comprendre ce que l'utilisateur veut faire.
Remplissage de créneaux: Extraire les informations clés (heure, lieu, etc.).
Suivi de l'état du dialogue: Gérer le contexte de conversation multi-tours.
Génération de réponses: Générer des réponses naturelles et professionnelles.
Implémentation du code
Implémentation d'un agent de service client
"""
Agent de service client
Gérer les demandes des utilisateurs et fournir une assistance de service
"""
def __init__(self, llm, knowledge_base, dialogue_manager):
self.llm = llm
# Base de connaissances
self.knowledge_base = knowledge_base
# Gestionnaire de dialogue
self.dialogue_manager = dialogue_manager
def handle(self, user_input, session_id):
"""
Traiter les messages utilisateur
"""
# Récupérer l'historique de la conversation
history = self.dialogue_manager.get_history(session_id)
# Reconnaître l'intention de l'utilisateur
intent = self.recognize_intent(user_input, history)
# Traiter en fonction de l'intention
if intent.type == "greeting":
response = self.handle_greeting()
elif intent.type == "inquiry":
response = self.handle_inquiry(intent)
elif intent.type == "complaint":
response = self.handle_complaint(intent)
elif intent.type == "order_status":
response = self.handle_order_status(intent)
elif intent.type == "refund":
response = self.handle_refund(intent)
else:
response = self.handle_general(user_input)
# Mettre à jour l'historique de conversation
self.dialogue_manager.add_message(
session_id,
{"role": "user", "content": user_input}
)
self.dialogue_manager.add_message(
session_id,
{"role": "assistant", "content": response}
)
return response
def recognize_intent(self, text, history):
"""Reconnaître l'intention de l'utilisateur"""
prompt = f"""
Analyser les messages de l'utilisateur et identifier le type d'intention.
Message actuel : {text}
Historique de la conversation :
{history}
Types d'intention :
- greeting : Salutation
- inquiry : Poser des questions
- complaint : Réclamation
- order_status : Vérifier la commande
- refund : Remboursement
- goodbye : Adieu
Veuillez indiquer le type d'intention et le niveau de confiance.
"""
result = self.llm.generate(prompt)
return Intent.parse(result)
def handle_inquiry(self, intent):
"""Gérer la demande"""
# Récupérer le contenu pertinent depuis la base de connaissances
relevant_docs = self.knowledge_base.search(intent.query)
if relevant_docs:
# S'il existe des documents pertinents, répondre en se basant sur les documents
prompt = f"""
Répondez à la question de l'utilisateur en vous basant sur le document suivant.
Document:
{relevant_docs}
Question: {intent.query}
"""
return self.llm.generate(prompt)
else:
# Aucun document pertinent, transférer à un humain ou consigner
return "Je dois mieux comprendre ce problème. Veuillez patienter pendant que je vérifie pour vous."
class Intent:
"""Intention de l'utilisateur"""
def __init__(self, type, query, confidence):
self.type = type
self.query = query
self.confidence = confidence
@classmethod
def parse(cls, text):
"""Analyser le texte de l'intention"""
# Implémentation simplifiée
return cls(type="inquiry", query=text, confidence=0.9)
Agent de recherche
L'agent de recherche peut mener des recherches approfondies de manière autonome, collecter et synthétiser des informations.
Simule le style de travail des chercheurs humains.
Capacités principales
Planification de recherche: Formuler un plan de collecte d'informations.
Collecte multi-sources: Collecter des informations à partir de plusieurs sources.
Vérification des informations: Vérifier l'exactitude des informations par recoupement.
Génération de rapports: Synthétiser les informations pour générer des rapports structurés.
Implémentation du code
Implémentation de l'agent de recherche
"""
Agent de recherche
Mener des recherches approfondies de manière autonome et générer des rapports
"""
def __init__(self, search_tools, llm):
# Liste des outils de recherche
self.search_tools = search_tools
self.llm = llm
def research(self, topic, depth=3):
"""
Exécuter la tâche de recherche
:param topic: Sujet de recherche
:param depth: Profondeur de recherche (nombre de cycles de recherche)
"""
# Étape 1 : Créer un plan de recherche
plan = self.create_research_plan(topic, depth)
# Étape 2 : Exécuter plusieurs cycles de recherche
findings = []
for phase in plan.phases:
# Rechercher dans plusieurs directions en parallèle
phase_results = self.search_phase(phase)
findings.extend(phase_results)
# Synthétiser les résultats actuels
synthesis = self.synthesize(findings)
findings.append({
"type": "synthesis",
"content": synthesis,
"phase": phase.number
})
# Étape 3 : Générer le rapport final
report = self.generate_report(findings)
return {
"topic": topic,
"plan": plan,
"findings": findings,
"report": report
}
def create_research_plan(self, topic, depth):
"""Créer un plan de recherche"""
prompt = f"""
Créez un plan détaillé pour le sujet de recherche suivant :
Sujet : {topic}
Profondeur : {depth}
Veuillez planifier :
1. Principaux axes nécessitant des recherches (3-5)
2. Questions clés auxquelles il faut répondre pour chaque axe
3. Suggestions de sources d'information
"""
return ResearchPlan.parse(self.llm.generate(prompt))
def search_phase(self, phase):
"""Exécuter une étape de recherche unique"""
results = []
for query in phase.queries:
# Utiliser les outils de recherche pour rechercher
for tool in self.search_tools:
search_results = tool.search(query)
results.extend(search_results)
return results
def synthesize(self, findings):
"""Synthétiser les résultats"""
prompt = f"""
Synthétisez les résultats de recherche suivants et extrayez les informations clés :
Liste des résultats :
{findings}
Veuillez extraire :
1. Conclusions principales
2. Preuves à l'appui des conclusions
3. Controverses ou incertitudes existantes
4. Questions nécessitant des recherches supplémentaires
"""
return self.llm.generate(prompt)
def generate_report(self, findings):
"""Générer le rapport final"""
prompt = f"""
Générez un rapport structuré basé sur les résultats de recherche suivants :
Résultats de recherche :
{findings}
Exigences du rapport :
1. Résumé exécutif
2. Introduction contextuelle
3. Principaux résultats (par sous-thème)
4. Conclusions et recommandations
5. Références
Veuillez générer un rapport complet.
"""
return self.llm.generate(prompt)
class ResearchPlan:
"""Plan de recherche"""
@classmethod
def parse(cls, text):
"""Analyser le texte du plan"""
# Implémentation simplifiée
return cls(phases=[
ResearchPhase(number=1, queries=["Sujet connexe 1"], goals=["Comprendre les concepts de base"]),
ResearchPhase(number=2, queries=["Sujet connexe 2"], goals=["Analyse approfondie"]),
])
def __init__(self, phases):
self.phases = phases
class ResearchPhase:
"""Phase de recherche"""
def __init__(self, number, queries, goals):
self.number = number
self.queries = queries
self.goals = goals
Autres applications verticales
RPA + Agent
La combinaison de la RPA (automatisation robotisée des processus) et de l'Agent.
Cela peut permettre l'automatisation de processus métier plus complexes.
L'Agent dote la RPA de capacités décisionnelles intelligentes.
Agent PNJ de jeu
Agents PNJ (personnages non-joueurs) dans les jeux.
Ils peuvent mener des dialogues dynamiques, générer des intrigues et jouer des rôles.
Créer une expérience de monde de jeu plus réaliste.
Agent de recherche scientifique
L'IA pour la science transforme la recherche scientifique.
Revue de littérature: lire et résumer automatiquement un grand nombre d'articles.
Conception d'expériences: proposer des plans expérimentaux et des hypothèses.
Analyse de données: traiter les données expérimentales et découvrir des tendances.
Rédaction d'articles: aider à rédiger des articles de recherche.
Résumé du chapitre
Ce chapitre présente les applications de l'Agent dans divers domaines verticaux.
Agent de codeAide à la programmation et améliore l'efficacité du développement.
Agent d'analyse de donnéesPermet également au personnel non technique d'analyser les données.
Agent de service clientFournit un service client intelligent.
Agent de rechercheMène des recherches approfondies de manière autonome.
Il existe également d'autres scénarios tels que RPA+Agent, les PNJ de jeu et les agents de recherche scientifique.
Les agents dans les domaines verticaux doivent être personnalisés avec des connaissances du domaine.
Choisir les bons scénarios et points d'entrée est la clé d'une mise en œuvre réussie.
Autres extensions