Aufbau eines strukturierten Forschungsautomationssystems mit Pydantic

Im dynamischen Bereich der akademischen Forschung sind effiziente Informationssammeln, Synthese und Präsentation von größter Bedeutung. Der manuelle Prozess der Literaturübersicht ist zeitaufwändig und behindert eine tiefere Analyse. Ein Multi-Agent-Forschungsassistenten, das mit pydantischer Sprache gebaut wurde, bietet eine hoch entwickelte Lösung: Spezialagenten arbeiten zusammen, um komplexe Aufgaben modular und skalierbar anzugehen. Das Verwalten mehrerer Agenten erfordert jedoch eine sorgfältige Berücksichtigung der Datenkonsistenz, Validierung und Kommunikation. Dieses pydantische System befasst sich mit diesen Herausforderungen, indem sie robuste Datenschemata durchsetzen, die Datenbearbeitung verbessern und die Systemkomplexität vereinfachen.

Dieser Artikel beschreibt die Konstruktion eines strukturierten Multi-Agent-Forschungsassistenten unter Verwendung von Pydantic, die Tools wie Pydantic-AI und Arxiv integriert. Wir werden Schritt-für-Schritt-Code-Erklärungen und erwartete Ergebnisse angeben.

Wichtige Lernziele

• Erfassen Sie die Bedeutung der strukturierten Datenmodellierung in einem pydantischen Multi-Agent-Forschungsassistenten für eine zuverlässige Kommunikation zwischen den Agenten.
• Definieren und implementieren Sie strukturierte Datenschemas mithilfe von Pydantic für nahtlose Integration, modularer Agentenorchestrierung und effiziente automatisierte Forschungsworkflows.
• Design- und Orchestrieren modulare Wirkstoffe für bestimmte Aufgaben: Abfrageverfeinerung, Datenabnahme, Keyword -Extraktion und Zusammenfassung.
• Integrieren Sie externe APIs (wie ARXIV) über strukturierte Agentenwechselwirkungen in automatisierte Workflows.
• Generieren Sie hochwertige Ausgänge (z. B. PDF-Berichte) direkt aus strukturierten Agentenausgängen, wodurch der praktische Nutzen automatisierter Forschungsworkflows verbessert wird.

Dieser Artikel ist Teil des Datenwissenschaftsblogathons.

Inhaltsverzeichnis

• Datenmodelle mit Pydantic definieren
• Strukturieren des Multi-Agent-Frameworks
• Verfeinerung von Abfragen mit dem prompt -Prozessoragenten
• Effizienter Papierabruf mit dem Papierabrufmittel
• Keyword -Extraktion mit dem Keyword Extraction Agent
• Vorsichtsfasste mit dem Zusammenfassungsagenten
• Orchestrierende Agenten
• Professionelle Ausgaben erzeugen
• Praktische Beispiele
• Abschluss
• Häufig gestellte Fragen

Datenmodelle mit Pydantic definieren

Gut definierte Datenmodelle sind in mehreren Agentensystemen von entscheidender Bedeutung. Der konstante, vorhersehbare Datenaustausch zwischen Agenten ist wesentlich. Pydantics elegant befasst sich mit einer einfachen Methode zum Definieren von Datenschemata in Python, der Sicherstellung der Datenkonsistenz, der Reduzierung von Laufzeitfehlern und der Ermöglichung der nahtlosen Validierung.

Hier ist ein Beispiel für strukturierte Datenmodelle mit Pydantic:

 aus pydantischem Import -Basemodel, Feld

Klasse Papermetadata (Basemodel):
    Titel: Str = Field (..., Beschreibung = "Papiertitel")
    Zusammenfassung: STR = Field (..., Beschreibung = "Papier Abstract")
    Autoren: Liste [STR] = Feld (..., Beschreibung = "Liste der Autoren")
    publication_date: str = field (..., Beschreibung = "Veröffentlichungsdatum")

Feld Erklärungen

• title : Papierentitel für einfache Referenz und Organisation.
• abstract : Übersichtliche Zusammenfassung für die Keyword -Extraktion und -produktion.
• authors : Autorenliste für weitere Abfragen oder Zitierverfolgung.
• publication_date : Veröffentlichungsdatum für Sortier und Filterung.

Unser System umfasst fünf Agenten:

• Eingabeaufforderung für Prozessoragent
• Papierabzug Agent
• Keyword Extraction Agent
• Zusammenfassungsvertreter
• Router (Orchestrator) Agent

Diese Agenten kommunizieren mithilfe der pydantischen Modelle, um vorhersehbare und validierte Daten zu gewährleisten, Fehler zu minimieren und die Robustheit des Systems zu verbessern.

Wir werden die Implementierung, Rolle und die erwarteten Ausgaben jedes Agenten eintauchen.

Strukturieren des Multi-Agent-Frameworks

Aufbauend auf den pydantischen Datenmodellen untersuchen wir nun den Multi-Agent-Framework. Jeder Agent hat eine bestimmte Rolle und interagiert nahtlos mit anderen.

Agentenrollen

• Eingabeaufforderung Prozessor Agent: Verfeinert Benutzeranfragen für eine verbesserte Suchrelevanz.
• Papierabruf Agent: Ruft relevante Arbeiten aus externen Datenbanken (wie Arxiv) ab.
• Keyword Extraction Agent: Extrahiert Schlüsselbegriffe aus Papier -Abstracts.
• SUMPERISIONIERUNGENTER: Erzeugt kurze Zusammenfassungen von Papier -Abstracts.
• Router Agent (Orchestrator): Koordiniert den Workflow, Verwaltung von Kommunikation und Datenfluss.

Agenteninteraktionen

Die Agenten interagieren nacheinander:

1. Der Eingabeaufforderungsprozessor verfeinert die Benutzerabfrage.
2. Die raffinierte Abfrage wird an den Papierabrufmittel gesendet.
3. Der Router sendet Abstracts an die Keyword -Extraktions- und Summarierungsagenten.
4. Der Router erstellt die Ergebnisse in einen Abschlussbericht.

Dieses modulare Design sorgt für die Wartbarkeit und Skalierbarkeit. Agenten können unabhängig verbessert oder ersetzt werden. Wir werden die Implementierung jedes Agenten untersuchen.

Forschungsabfragen mit dem prompt -Prozessoragenten verfeinern

Genaue Abfragen sind für eine effektive Suche von entscheidender Bedeutung. Der Eingabeaufforderungsprozessor -Agent verfeinert Benutzeranfragen, um die Relevanz von Ergebnissen aus akademischen Datenbanken zu verbessern.

Hier ist die Implementierung von Proform Processor Agent:

 @prompt_processor_agent.tool
Async def process_prompt (ctx: runcontext [researchContext], Thema: str) -> str:
    topic = topic.strip (). Lower ()
    Wenn 'in' im Thema:
        subtopics = topic.split ('in')
        main_topic = subtopics [0] .strip ()
        context = subtopics [1] .strip ()
        Refined_query = f "All: {main_topic} und cat: {context.replace ('', '_')}"
    anders:
        raffined_query = f "ti: \" {topic} \ "oder abs: \" {topic} \ "" "
    return refined_query zurückgeben

Diese verbesserte Implementierung normalisiert die Input, Parsen kontextbezogene Hinweise ("in"), baut strukturierte Abfragen auf und beinhaltet Fallling für breitere Themen. Dies führt zu genaueren Suchanfragen.

Forschungsarbeiten effizient mit dem Papierabrufmittel abrufen

Der Papierabrufmittel interagiert mit externen APIs (wie Arxiv), um relevante Papiere basierend auf der raffinierten Abfrage abzurufen. Es verwendet pydantische Modelle für die konsistente Datenhandhabung.

 @paper_retrieval_agent.tool
Async Def fetch_papers (CTX: RunContext [ResearchContext]) -> Liste [Papermetadata]:
    search = arxiv.search (query = ctx.deps.Query, max_results = 5, sort_by = arxiv.sortcriterion.SubMondDDate)
    resultes = list (search.results ())
    Papiere = []
    Für Ergebnisse: Ergebnisse:
        published_str = result.Published.Strftime ("%y-%M-%d") if HasAttr (Ergebnis "veröffentlicht") und Ergebnis.
        papier = papermetadata (title = result.titel, Abstract = result.summary, Authors = [Autor.Name für den Autor in Ergebnis.Authors], publication_date = published_str)
        Papiere.Append (Papier)
    Rückgabepapiere

Pydantic gewährleistet die Datenvalidierung und -konsistenz und vereinfacht die nachgeschaltete Verarbeitung.

Extrahieren wertvoller Schlüsselwörter mit dem Schlüsselwort Extraction Agent

Der Keyword Extraction Agent identifiziert wichtige Begriffe von Abstracts, um Forschern bei der schnellen Bewertung der Papierrelevanz zu helfen.

 @keyword_extraction_agent.tool
Async def extract_keywords (CTX: RunContext [ResearchContext], Abstract: STR) -> KeywordResult:
    Wörter = Abstract.split ()
    gesehen = set ()
    Unique_words = []
    Für Wort in Worten:
        Normalisiert = word.strip ('.,;: "()'). Lower ()
        Wenn es normalisiert und nicht in gesehen ist: nicht gesehen:
            gesehen.add (normalisiert)
            Unique_words.append (normalisiert)
        Wenn Len (einzigartig_words)> = 5:
            brechen
    KeywordResult zurückgeben (Keywords = eindeutig_words)

Dies ist ein vereinfachtes Beispiel; Produktionssysteme würden fortschrittlichere NLP -Techniken verwenden. Pydantic hält strukturierte, konsistente Ausgänge.

Zusammenfassungen von Papieren mit dem Zusammenfassungsagenten

Der Zusammenfassungsagent erzeugt kurze Zusammenfassungen von Abstracts.

 @summary_agent.tool
Async def scräxize_paper (ctx: runcontext [researchContext], Abstract: str) -> papersummary:
    summary_text = Abstract [: 150] "...", wenn len (Abstract)> 150 sonst abstrakt
    return paperSummary (summary = summary_text)

Dies ist ein grundlegendes Beispiel; Fortgeschrittene Summarierungsmodelle könnten die Qualität der Zusammenfassungen erheblich verbessern.

Alles zusammenbringen: Agentenorchestrierung

Der Router -Agent organisiert den gesamten Workflow.

 @router_agent.tool
Async def orchestrate_workflow (ctx: runcontext [researchContext]) -> str:
    raffined_query = erwarten Sie prompt_processor_agent.run (ctx.deps.Query, DEPS = ctx.deps)
    paper = wartet paper_retrieval_agent.run (raffined_query.data, deps = ctx.deps)
    Antwort = "Abschlussbericht: \ n"
    für Papier in Papieren.Data:
        Keywords = Warten Sie keyword_extraction_agent.run (paper.abstract, deps = ctx.deps)
        summary = warte summary_agent.run (paper.abstract, deps = ctx.deps)
        Antwort = ((
            f "\ ntitle: {paper.title} \ n"
            f "Schlüsselwörter: {keywords.data.Keywords} \ n"
            f "Zusammenfassung: {summary.data.summary} \ n"
        )
    Rückgabeantwort

Dies verwendet asynchrone Operationen zur Effizienz. Strukturierte Protokollierungshilfen -Debugging.

Erzeugen Sie professionelle Ausgänge mit strukturierten Daten

Die strukturierten Daten werden in einen professionellen PDF -Bericht umgewandelt.

 Def generate_pdf_report (report_text: str, output_fileName: str = "final_report.pdf"):
    Import Markdown2
    von xhtml2pdf import PISA
    html_text = markdown2.markdown (report_text)
    mit open (output_filename, "wb") als result_file:
        pisa.createpdf (html_text, dest = result_file)

Dies nutzt die strukturierten Daten für eine einfache Konvertierung in ein lesbares PDF.

Multi-Agent-System in Aktion: Praktische Beispiele

Die Wirksamkeit des Systems wird anhand von Beispielen demonstriert. (Beispiele würden hier aufgenommen, wobei die Ausgabe des Systems für verschiedene Forschungsthemen angezeigt wird.)

Abschluss

Dieses mit Pydantic erstellte Multi-Agent-Forschungsassistentensystem automatisiert effizient Forschungsworkflows und generiert professionelle Berichte. Die strukturierte Datenbehandlung von Pydantic ist der Schlüssel zur Zuverlässigkeit und Skalierbarkeit des Systems.

Häufig gestellte Fragen

(FAQs würden hier aufgenommen, um gemeinsame Fragen zum System zu beantworten.)

(Hinweis: Die Bild- und Code -Snippets sind Platzhalter. Der vollständige Code müsste separat bereitgestellt werden.)

Das obige ist der detaillierte Inhalt vonAufbau eines strukturierten Forschungsautomationssystems mit Pydantic. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!