Système de résolution de requête simultanée utilisant Crewai

À l'ère de l'intelligence artificielle, les entreprises recherchent constamment des moyens innovants pour améliorer les services de support client. Une telle approche est de tirer parti des agents d'IA qui travaillent en collaboration pour résoudre efficacement les requêtes des clients. Cet article explore la mise en œuvre d'un système de résolution de requête simultané à l'aide de Crewai, des modèles GPT d'OpenAI et Google Gemini. Ce système utilise plusieurs agents spécialisés qui opèrent en parallèle pour gérer les requêtes des clients de manière transparente, réduisant le temps de réponse et améliorant la précision.

Objectifs d'apprentissage

• comprendre comment les agents de l'IA peuvent gérer efficacement les requêtes des clients en automatisant les réponses et en résumant les informations clés.
• Découvrez comment Crewai permet une collaboration multi-agents pour améliorer les flux de travail du support client.
• Explorez différents types d'agents d'IA, tels que les résolveurs de requête et les résumés, et leurs rôles dans l'automatisation du service client.
• Implémentez le traitement des requêtes simultanées à l'aide de l'asyncio de Python pour améliorer l'efficacité de la réponse.
• Optimiser les systèmes de support client en intégrant l'automatisation dirigée par l'IA pour une précision et une évolutivité améliorées.

Cet article a été publié dans le cadre du Data Science Blogathon.

Table des matières

• Comment les agents Ai fonctionnent ensemble?
• Implémentation du système de résolution de requête simultanée
  • Étape 1: Définition de la clé API
  • Étape 2: Importation des bibliothèques requises
  • Étape 3: Initialisation LLMS
  Agents
  Étape 5: Définition des tâches
  Étape 6: Exécution d'une requête avec des agents AI
  Étape 7: Gestion des requêtes multiples simultanément
  Étape 8: Définition Exemple de requêtes
  Étape 9: Configuration de la laine d'événements
  Étape 10: Faire des avantages Jupy. Colab
  Étape 11: Exécution des requêtes et des résultats d'impression
Avantages du système de résolution de requête simultanée
Applications du système de résolution de requête simultanée
Conclusion
Les questions fréquemment posées

comment les agents de l'IA fonctionnent ensemble?

Le système de résolution de requête simultanée utilise un cadre multi-agents, attribuant à chaque agent un rôle spécifique. Le système utilise Crewai, un cadre qui permet aux agents de l'IA de collaborer efficacement.

Les principaux composants du système comprennent:

• Agent de résolution de requête: Responsable de comprendre les requêtes des clients et de fournir des réponses précises.
• Agent de résumé: résume le processus de résolution pour une revue rapide et une référence future.
• LLMS (modèles de grande langue): comprend des modèles comme GPT-4O et Gemini, chacun avec différentes configurations pour équilibrer la vitesse et la précision.
• Gestion des tâches: Affecter dynamiquement les tâches aux agents pour assurer un traitement de requête simultané.

Implémentation du système de résolution de requête simultanée

Pour transformer le cadre de l'agent AI du concept en réalité, une approche de mise en œuvre structurée est essentielle. Ci-dessous, nous décrivons les étapes clés impliquées dans la mise en place et l'intégration d'agents d'IA pour une résolution de requête efficace.

Étape 1: Définition de la clé API

La touche API OpenAI est stockée sous forme de variable d'environnement à l'aide du module OS. Cela permet au système d'authentifier les demandes d'API en toute sécurité sans les informations d'identification sensibles à codage rigide.

import os 

# Set the API key as an environment variable
os.environ["OPENAI_API_KEY"] = ""

Le système utilise le module OS pour interagir avec le système d'exploitation.

Le système définit l'Openai_API_KEY en tant que variable d'environnement, ce qui lui permet d'authentifier les demandes d'Openai API.

Étape 2: Importation de bibliothèques requises

Les bibliothèques nécessaires sont importées, y compris Asyncio pour gérer les opérations asynchrones et les composants de Crewai comme l'agent, l'équipe, la tâche et le LLM. Ceux-ci sont essentiels pour définir et gérer les agents d'IA.

import asyncio
from crewai import Agent, Crew, Task, LLM, Process
import google.generativeai as genai

• asyncio: Module intégré de Python pour la programmation asynchrone, permettant une exécution simultanée.
• Agent: représente un travailleur AI avec des responsabilités spécifiques.
• Crew: gère plusieurs agents et leurs interactions.
• Tâche: définit ce que chaque agent est censé faire.
• llm: Spécifie le modèle grand langage utilisé.
• Processus: Il définit comment les tâches s'exécutent, qu'elles soient séquentiellement ou en parallèle.
• google.generativeai: bibliothèque pour travailler avec les modèles d'IA génératifs de Google (non utilisés dans cet extrait, mais probablement inclus pour une expansion future).

Étape 3: Initialisation des LLMS

Trois instances LLM différentes (GPT-4O et GPT-4) sont initialisées avec différents réglages de température. La température contrôle la créativité de la réponse, assurant un équilibre entre la précision et la flexibilité dans les réponses générées par l'AI.

# Initialize the LLM with Gemini
llm_1 = LLM(
    model="gpt-4o",
    temperature=0.7)
llm_2 = LLM(
    model="gpt-4",
    temperature=0.2)
llm_3 = LLM(
    model="gpt-4o",
    temperature=0.3)

Le système crée trois instances LLM, chacune avec une configuration différente.

Paramètres:

• Modèle: Spécifie le modèle OpenAI à utiliser (GPT-4O ou GPT-4).
• Température: contrôle le caractère aléatoire dans les réponses (0 = déterministe, 1 = plus créatif).

Ces différents modèles et températures aident à équilibrer la précision et la créativité

Étape 4: Définition des agents AI

Chaque agent a un rôle spécifique et des objectifs prédéfinis. Deux agents d'IA sont créés:

• Resolver de requête : gère les demandes des clients et fournit des réponses détaillées.
• Générateur de résumé : résume les résolutions pour référence rapide.
  Chaque agent a un rôle, un objectif et une trame de fond définis pour guider ses interactions.

Agent de résolution de requête

import os 

# Set the API key as an environment variable
os.environ["OPENAI_API_KEY"] = ""

Voyons ce qui se passe dans ce bloc de code

• Création d'agent: La question_rèvement_agent est un assistant propulsé par l'AI responsable de la résolution des requêtes des clients.
• Sélection du modèle: Il utilise LLM_1, configuré comme GPT-4O avec une température de 0,7. Cet équilibre permet des réponses créatives mais précises.
• Rôle: Le système désigne l'agent en tant que résolveur de requête.
• Backstory: Les développeurs programment l'agent pour agir en tant qu'assistante à la clientèle professionnelle, garantissant des réponses efficaces et professionnelles.
• Objectif: pour fournir des solutions précises aux requêtes utilisateur.
• MODE VERBOSE: Verbose = true assure des journaux détaillés, aidant les développeurs à déboguer et à suivre ses performances.

Agent de résumé

import asyncio
from crewai import Agent, Crew, Task, LLM, Process
import google.generativeai as genai

Que se passe-t-il ici?

• Création d'agent: Le résumé_agent est conçu pour résumer les résolutions de requête.
• Sélection du modèle: utilise LLM_2 (GPT-4) avec une température de 0,2, ce qui rend ses réponses plus déterministes et précis.
• Rôle: Cet agent agit comme un générateur de résumé.
• Backstory: Il résume les résolutions de requête concises pour référence rapide.
• Objectif: Il fournit un résumé clair et concis de la façon dont les requêtes des clients ont été résolues.
• Mode Verbose: Verbose = true garantit que des informations de débogage sont disponibles si nécessaire.

Étape 5: Définition des tâches

Le système attribue dynamiquement des tâches pour assurer le traitement parallèle des requêtes.

Cette section définit les tâches attribuées aux agents d'IA dans le système de résolution de requête simultanée.

# Initialize the LLM with Gemini
llm_1 = LLM(
    model="gpt-4o",
    temperature=0.7)
llm_2 = LLM(
    model="gpt-4",
    temperature=0.2)
llm_3 = LLM(
    model="gpt-4o",
    temperature=0.3)

Que se passe-t-il ici?

Définition des tâches:

• Resolution_task: cette tâche ordonne à l'agent de résolveur de requête d'analyser et de résoudre les requêtes des clients.
• Résumé_task: Cette tâche ordonne à l'agent récapitulatif de générer un bref résumé du processus de résolution.

Gestion de la requête dynamique:

• Le système remplace {query} par une requête client réelle lors de l'exécution de la tâche.
• Cela permet au système de gérer dynamiquement toute requête client.

Sortie attendue:

• La résolution_task s'attend à une réponse détaillée à la requête.
• Le résumé_task génère un résumé concis de la résolution de requête.

Affectation d'agent:

• Le requête_resolution_agent est affecté pour gérer les tâches de résolution.
• Le résumé_agent est affecté pour gérer les tâches de résumé.

pourquoi cela compte

• Spécialisation des tâches: Chaque agent AI a un travail spécifique, assurant l'efficacité et la clarté.
• Évolutivité: Vous pouvez ajouter plus de tâches et d'agents pour gérer différents types d'interactions de support client.
• Traitement parallèle: Les tâches peuvent être exécutées simultanément, réduisant les temps d'attente des clients.

Étape 6: Exécution d'une requête avec des agents AI

Une fonction asynchrone est créée pour traiter une requête. La classe d'équipage organise des agents et des tâches, en les exécutant séquentiellement pour assurer une bonne résolution et un résumé de la requête.

import os 

# Set the API key as an environment variable
os.environ["OPENAI_API_KEY"] = ""

Cette fonction définit un processus asynchrone pour exécuter une requête. Il crée une instance d'équipage, qui comprend:

• Agents: Les agents AI impliqués dans le processus (Resolver de requête et générateur de résumé).
• Tâches: Tâches attribuées aux agents (résolution et résumé de la requête).
• process = process.ondedential: s'assure que les tâches sont exécutées en séquence.
• verbose = true: permet une journalisation détaillée pour un meilleur suivi.

La fonction utilise l'attente pour exécuter les agents AI de manière asynchrone et renvoie le résultat.

Étape 7: Gestion de plusieurs requêtes simultanément

En utilisant asyncio.gather (), plusieurs requêtes peuvent être traitées simultanément. Cela réduit le temps de réponse en permettant aux agents de l'IA de gérer différents problèmes de clients en parallèle.

import asyncio
from crewai import Agent, Crew, Task, LLM, Process
import google.generativeai as genai

Cette fonction exécute deux requêtes simultanément. Asyncio.gather () traite les deux requêtes simultanément, réduisant considérablement le temps de réponse. La fonction renvoie les résultats des deux requêtes une fois l'exécution terminée

Étape 8: Définition d'exemples de requêtes

Les développeurs définissent des échantillons de requêtes pour tester le système, couvrant les problèmes communs de support client tels que les défaillances de connexion et les erreurs de traitement des paiements.

# Initialize the LLM with Gemini
llm_1 = LLM(
    model="gpt-4o",
    temperature=0.7)
llm_2 = LLM(
    model="gpt-4",
    temperature=0.2)
llm_3 = LLM(
    model="gpt-4o",
    temperature=0.3)

Ce sont des échantillons de requêtes pour tester le système.

La requête 1 traite des problèmes de connexion, tandis que la requête 2 concerne les erreurs de passerelle de paiement.

Étape 9: Configuration de la boucle d'événement

Le système initialise une boucle d'événement pour gérer les opérations asynchrones. S'il ne trouve pas de boucle existante, il en crée un nouveau pour gérer l'exécution des tâches AI.

import os 

# Set the API key as an environment variable
os.environ["OPENAI_API_KEY"] = ""

Cette section garantit qu'une boucle d'événement est disponible pour l'exécution de tâches asynchrones.

Si le système ne détecte aucune boucle d'événement (RuntimeError se produit), il en crée un nouveau et le définit comme la boucle active.

Étape 10: Gestion des boucles d'événements dans Jupyter Notebook / Google Colab

Étant donné que Jupyter et Colab ont des boucles d'événements préexistantes, Nest_asyncio.Apply () est utilisé pour empêcher les conflits, garantissant une exécution fluide des requêtes asynchrones.

import asyncio
from crewai import Agent, Crew, Task, LLM, Process
import google.generativeai as genai

Les cahiers Jupyter et Google Colab ont des boucles d'événements préexistantes, ce qui peut entraîner des erreurs lors de l'exécution des fonctions asynchrones.

nest_asyncio.apply () permet des boucles d'événements imbriquées, résoudre les problèmes de compatibilité.

Étape 11: Exécution des requêtes et des résultats d'impression

La boucle d'événement exécute manche_two_queries () pour traiter les requêtes simultanément. Le système imprime les réponses finales générées par l'AI, affichant des résolutions et des résumés de requête.

# Initialize the LLM with Gemini
llm_1 = LLM(
    model="gpt-4o",
    temperature=0.7)
llm_2 = LLM(
    model="gpt-4",
    temperature=0.2)
llm_3 = LLM(
    model="gpt-4o",
    temperature=0.3)

loop.run_until_complete () démarre l'exécution de manche_two_queries (), qui traite les deux requêtes simultanément.

Le système imprime les résultats, affichant les résolutions générées par l'AI pour chaque requête.

Avantages du système de résolution de requête simultanée

ci-dessous, nous verrons comment le système de résolution de requête simultanée améliore l'efficacité en traitant simultanément plusieurs requêtes, conduisant à des temps de réponse plus rapides et à une amélioration de l'expérience utilisateur.

• Temps de réponse plus rapide: L'exécution parallèle résout plusieurs requêtes simultanément.
• Précision améliorée: Tirer parti de plusieurs LLMS assure un équilibre entre la créativité et l'exactitude factuelle.
• Évolutivité: Le système peut gérer un volume élevé de requêtes sans intervention humaine.
• Une meilleure expérience client: Les résumés automatisés fournissent un aperçu rapide des résolutions de requête.

Applications du système de résolution de requête simultanée

Nous allons maintenant explorer les différentes applications du système de résolution de requête simultanée, y compris l'automatisation du support client, la gestion des requêtes en temps réel dans les chatbots et le traitement efficace des demandes de service à grande échelle.

• Automatisation du support client : permet aux chatbots dirigés par AI de résoudre plusieurs requêtes client simultanément, en réduisant le temps de réponse.
• Traitement des requêtes en temps réel : Améliore les systèmes de support en direct en gérant de nombreuses requêtes en parallèle, améliorant l'efficacité.
• Assistance au commerce électronique : rationalise les demandes de produits, le suivi des commandes et les résolutions des problèmes de paiement dans les plateformes d'achat en ligne.
• It Helpdesk Management : prend en charge les bureaux de service informatique en diagnostiquant et en résolvant plusieurs problèmes techniques simultanément.
• Healthcare & Télédecine : Aide à gérer simultanément les demandes de renseignements des patients, la planification des rendez-vous et les conseils médicaux.

Conclusion

Le système de résolution de requête simultanée montre comment la collaboration multi-agents axée sur l'IA peut révolutionner le support client. En tirant parti de Crewai, des modèles GPT d'OpenAI et Google Gemini, les entreprises peuvent automatiser la manipulation des requêtes, l'amélioration de l'efficacité et la satisfaction des utilisateurs. Cette approche ouvre la voie à des solutions de service plus avancées axées sur l'IA à l'avenir.

Les plats clés

• Les agents AI rationalisent le support client, réduisant les temps de réponse.
• Crewai permet aux agents spécialisés de travailler efficacement ensemble.
• En utilisant asyncio, plusieurs requêtes sont traitées simultanément.
• Différentes configurations LLM Équilibrez la précision et la créativité.
• Le système peut gérer des volumes de requête élevés sans intervention humaine.
• Les résumés automatisés fournissent des résolutions de requête rapides et claires.

Les questions fréquemment posées

Q1. Qu'est-ce que Crewai?

a. Crewai est un cadre qui permet à plusieurs agents d'IA de travailler en collaboration sur des tâches complexes. Il permet la gestion des tâches, la spécialisation des rôles et la coordination transparente entre les agents.

Q2. Comment fonctionne Crewai?

a. Crewai définit les agents avec des rôles spécifiques, attribue des tâches dynamiquement et les traite séquentiellement ou simultanément. Il exploite les modèles AI comme GPT et Google Gemini d'OpenAI pour exécuter efficacement les tâches.

Q3. Comment Crewai gère-t-il plusieurs requêtes simultanément?

a. Crewai utilise Asyncio.gather () de Python pour exécuter plusieurs tâches simultanément, garantissant une résolution de requête plus rapide sans goulot d'étranglement de performance.

Q4. Crewai peut-il s'intégrer à différents LLMS?

a. Oui, Crewai prend en charge divers modèles de grande langue (LLMS), y compris les GPT-4, GPT-4O d'OpenAI, et les Gémeaux de Google, permettant aux utilisateurs de choisir en fonction des exigences de vitesse et de précision.

Q5. Comment Crewai assure la précision des tâches?

a. En utilisant différents modèles d'IA avec des paramètres de température variés, Crewai équilibre la créativité et l'exactitude factuelle, assurant des réponses fiables.

Le média présenté dans cet article ne appartient pas à l'analyse vidhya et est utilisé à la discrétion de l'auteur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!