Construire un système d'automatisation de la recherche structurée à l'aide de pydance

Dans le domaine dynamique de la recherche académique, la collecte efficace d'informations, la synthèse et la présentation sont primordiales. Le processus manuel de revue de la littérature prend du temps, ce qui entoure une analyse plus approfondie. Un système d'assistants de recherche multi-agents construit avec Pydantic offre une solution sophistiquée: les agents spécialisés collaborent pour lutter contre les tâches complexes modulaire et évolutive. Cependant, la gestion des multiples agents nécessite un examen attentif de la cohérence des données, de la validation et de la communication. Ce système basé sur pydance relève ces défis en appliquant des schémas de données robustes, en améliorant la gestion des données et en simplifiant la complexité du système.

Cet article détaille la construction d'un assistant de recherche multi-agents structuré utilisant des outils d'intégration de Pyndantic, comme Pyndantic-AI et Arxiv. Nous fournirons des explications de code étape par étape et des résultats attendus.

Objectifs d'apprentissage clés

• Saisissez l'importance de la modélisation structurée des données dans un assistant de recherche multi-agents alimentaire à alimentation pyndante pour une communication inter-agents fiable.
• Définissez et implémentez les schémas de données structurés à l'aide de Pydtic pour l'intégration transparente, l'orchestration des agents modulaires et les flux de travail de recherche automatisés efficaces.
• Conception et orchestrer des agents modulaires pour des tâches spécifiques: raffinement de requête, récupération des données, extraction de mots clés et résumé.
• Intégrez les API externes (comme ArXIV) dans des flux de travail automatisés via des interactions d'agent structurées.
• Générez des sorties de haute qualité (par exemple, rapports PDF) directement à partir de sorties d'agent structurées, améliorant l'utilité pratique des flux de travail de recherche automatisés.

Cet article fait partie du blogathon des sciences des données.

Table des matières

• Définition de modèles de données avec pydance
• Structurer le cadre multi-agent
• Affiner les requêtes avec l'agent processeur rapide
• Récupération de papier efficace avec l'agent de récupération de papier
• Extraction de mots clés avec l'agent d'extraction de mots clés
• Résumé concis avec l'agent de résumé
• Agents orchestrés
• Générer des sorties professionnelles
• Exemples pratiques
• Conclusion
• Questions fréquemment posées

Définition de modèles de données avec pydance

Les modèles de données bien définis sont cruciaux dans les systèmes multi-agents. L'échange de données cohérent et prévisible entre les agents est essentiel. Pyndantic s'adresse avec élégance en fournissant une méthode simple pour définir des schémas de données dans Python, en assurant la cohérence des données, en réduisant les erreurs d'exécution et en permettant une validation transparente.

Voici un exemple de modèles de données structurés à l'aide de Pyndantique:

 de Pydantic Import Basemodel, champ

Papermemetadata de classe (Basemodel):
    Titre: str = champ (..., description = "titre papier")
    Résumé: str = champ (..., description = "Résumé de papier")
    auteurs: list [str] = champ (..., description = "liste des auteurs")
    publication_date: str = champ (..., description = "Date de publication")

Explications sur le terrain

• title : Titre papier pour une référence et une organisation faciles.
• abstract : Résumé concis pour l'extraction et le résumé des mots clés.
• authors : Liste des auteurs pour d'autres requêtes ou suivi des citations.
• publication_date : Date de publication pour le tri et le filtrage.

Notre système comprend cinq agents:

• Agent processeur rapide
• Agent de récupération de papier
• Agent d'extraction de mots clés
• Agent de résumé
• Agent routeur (orchestrateur)

Ces agents communiquent en utilisant les modèles définis par pydance, garantissant des données prévisibles et validées, minimisant les erreurs et améliorant la robustesse du système.

Nous allons approfondir la mise en œuvre, le rôle et les sorties attendues de chaque agent.

Structurer le cadre multi-agent

S'appuyant sur les modèles de données pydantes, nous examinons maintenant le cadre multi-agents. Chaque agent a un rôle spécifique et interagit de manière transparente avec les autres.

Rôles d'agent

• Agent de processeur rapide: affine les requêtes utilisateur pour une meilleure pertinence de recherche.
• Agent de récupération de papier: récupère les articles pertinents des bases de données externes (comme ArXIV).
• Agent d'extraction de mots clés: extrait les termes clés des résumés de papier.
• Agent de résumé: génère des résumés concis des résumés de papier.
• Agent de routeur (Orchestrator): coordonne le flux de travail, gérant la communication et le flux de données.

Interactions d'agent

Les agents interagissent séquentiellement:

1. Le processeur rapide affine la requête utilisateur.
2. La requête raffinée est envoyée à l'agent de récupération de papier.
3. Le routeur envoie des résumés aux agents d'extraction et de résumé des mots clés.
4. Le routeur compile les résultats dans un rapport final.

Cette conception modulaire garantit la maintenabilité et l'évolutivité. Les agents peuvent être améliorés ou remplacés indépendamment. Nous explorerons la mise en œuvre de chaque agent.

Affiner les requêtes de recherche avec l'agent processeur rapide

Les requêtes précises sont essentielles pour une recherche efficace. L'agent processeur rapide affine les requêtes utilisateur pour améliorer la pertinence des résultats des bases de données académiques.

Voici la mise en œuvre de l'agent processeur rapide:

 @ prompt_processor_agent.tool
Async Def Process_prompt (CTX: RunContext [ResearchContext], Sujet: Str) -> Str:
    topic = topic.strip (). inférieur ()
    Si «dans» dans le sujet:
        subtopecs = topic.split ('in')
        main_topic = subtopics [0] .strip ()
        context = subtopes [1] .strip ()
        raffined_query = f "all: {main_topic} et cat: {context.replace ('', '_')}"
    autre:
        raffined_query = f "Ti: \" {topic} \ "ou abse: \" {topic} \ ""
    retour raffiné_query

Cette mise en œuvre améliorée normalise les entrées, analyse les indices contextuels ("in"), construit des requêtes structurées et comprend une manipulation de secours pour des sujets plus larges. Cela conduit à des recherches plus précises.

Rechercher efficacement les documents de recherche avec l'agent de récupération de papier

L'agent de récupération de papier interagit avec les API externes (comme ArXIV) pour récupérer des articles pertinents sur la base de la requête raffinée. Il utilise des modèles pydantes pour une gestion cohérente des données.

 @ Paper_Retrieval_Agent.Tool
async def fetch_papers (ctx: runContext [ResearchContext]) -> list [PaperMetAdata]:
    search = arXiv.search (query = ctx.deps.query, max_results = 5, sort_by = arXiv.sortcriterion.sumittedDate)
    résultats = liste (search.results ())
    papiers = []
    pour résultat dans les résultats:
        publié_str = résultat.Publié.Strftime ("% y-% m-% d") si Hasattr (résultat, "publié") et le résultat.édiction n'est pas "inconnu"
        Paper = PapermemetAdata (title = result.title, abstract = result.summary, auteurs = [auteur.name pour l'auteur dans le résultat.auteur], publication_date = publied_str)
        papiers.APPEND (papier)
    papiers de retour

Pydontic garantit la validation et la cohérence des données, simplifiant le traitement en aval.

Extraction de mots clés précieux avec l'agent d'extraction de mots clés

L'agent d'extraction de mots clés identifie les termes clés des résumés pour aider les chercheurs à évaluer rapidement la pertinence du papier.

 @ keyword_extraction_agent.tool
Async Def extract_keywords (CTX: RunContext [ResearchContext], Résumé: Str) -> KeywordResult:
    mots = abstract.split ()
    vu = set ()
    unique_words = []
    pour mot en mots:
        normalisé = word.strip ('. ,;: "()'). inférieur ()
        Si normalisé et normalisé pas dans le vu:
            vu.add (normalisé)
            UNIQUE_WORDS.APPEND (normalisé)
        Si LEN (UNIQUE_WORDS)> = 5:
            casser
    return keywordResult (keywords = unique_words)

Ceci est un exemple simplifié; Les systèmes de production utiliseraient des techniques de PNL plus avancées. Pyndantique maintient des sorties structurées et cohérentes.

Résumer les articles avec concise avec l'agent de résumé

L'agent de résumé génère des résumés concis des résumés.

 @ résumé_agent.tool
Async Def Summarize_paper (CTX: RunContext [ResearchContext], Résumé: STR) -> PAPERSUMMARY:
    Summary_text = Résumé [: 150] "..." If Len (Résumé)> 150 Else Résumé
    return papersummary (résumé = résumé_text)

Ceci est un exemple de base; Les modèles de résumé avancés pourraient améliorer considérablement la qualité des résumés.

Rassembler tout cela: orchestration agentique

L'agent du routeur orchestre l'ensemble du flux de travail.

 @ router_agent.tool
async def orchestrate_workflow (ctx: runContext [ResearchContext]) -> str:
    raffined_query = attendre prompt_processor_agent.run (ctx.deps.query, deps = ctx.deps)
    papiers = attendre paper_retrieval_agent.run (raffiné_query.data, deps = ctx.deps)
    réponse = "rapport final: \ n"
    pour papier dans papiers.data:
        Keywords = Await Keyword_Extraction_Agent.Run (Paper.Abstract, Deps = CTX.DEPS)
        Résumé = attendre résumé_agent.run (paper.abstract, DEPS = ctx.deps)
        réponse = (
            f "\ ntitle: {papier.title} \ n"
            f "Mots-clés: {Keywords.data.keywords} \ n"
            f "Résumé: {résumé.data.summary} \ n"
        )
    Réponse de retour

Cela utilise des opérations asynchrones pour l'efficacité. Débogage des aides à l'exploitation forestière structurée.

Générer des sorties professionnelles avec des données structurées

Les données structurées sont converties en un rapport PDF professionnel.

 DEF Generate_pdf_Report (report_text: str, output_filename: str = "final_report.pdf"):
    Importer Markdown2
    à partir de xhtml2pdf import Pisa
    html_text = markdown2.markdown (report_text)
    avec open (output_filename, "wb") comme résultat_file:
        PISA.CreatePdf (HTML_Text, dest = result_file)

Cela exploite les données structurées pour une conversion facile en un PDF lisible.

Système multi-agent en action: exemples pratiques

L'efficacité du système est démontrée par des exemples. (Des exemples seraient inclus ici, montrant la sortie du système pour différents sujets de recherche.)

Conclusion

Ce système d'assistants de recherche multi-agents, construit avec Pyndantic, automatise efficacement les workflows de recherche et génère des rapports professionnels. La manipulation structurée des données de Pyndantique est la clé de la fiabilité et de l'évolutivité du système.

Questions fréquemment posées

(Les FAQ seraient incluses ici, abordant des questions courantes sur le système.)

(Remarque: les extraits d'image et de code sont des espaces réservés. Le code complet devrait être fourni séparément.)

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!