In diesem Tutorial führen wir Sie durch die Entwicklung eines fortschrittlichen Graphagenten -Frameworks, das von der Google Gemini -API betrieben wird. Unser Ziel ist es, intelligente, mehrstufige Agenten aufzubauen, die Aufgaben durch eine genau definierte Graphenstruktur miteinander verbundener Knoten ausführen. Jeder Knoten stellt eine bestimmte Funktion dar, die von der Eingabe der Eingabe, der logischen Verarbeitung, der Treffen von Entscheidungen und der Erzeugung von Ausgängen reicht. Wir verwenden Python, NetworkX für die Graph -Modellierung und Matplotlib zur Visualisierung. Am Ende implementieren und führen wir zwei vollständige Beispiele aus, einen Forschungsassistenten und einen Problemlöser, um zu demonstrieren, wie das Framework komplexe Argumentations -Workflows effizient bewältigen kann.
!pip set up -q google-generativeai networkx matplotlib
import google.generativeai as genai
import networkx as nx
import matplotlib.pyplot as plt
from typing import Dict, Record, Any, Callable
import json
import asyncio
from dataclasses import dataclass
from enum import Enum
API_KEY = "use your API key right here"
genai.configure(api_key=API_KEY)
Wir beginnen mit der Set up der erforderlichen Bibliotheken, Google-Generativai, Networkx und Matplotlib, um unser graphbasiertes Agenten-Framework zu unterstützen. Nach dem Importieren von wesentlichen Modulen konfigurieren wir die Gemini -API mit unserem API -Schlüssel, um leistungsstarke Funktionen für die Erzeugung von Inhalten in unserem Agentensystem zu ermöglichen.
Schauen Sie sich das an Codes.
class NodeType(Enum):
INPUT = "enter"
PROCESS = "course of"
DECISION = "choice"
OUTPUT = "output"
@dataclass
class AgentNode:
id: str
sort: NodeType
immediate: str
perform: Callable = None
dependencies: Record(str) = NoneWir definieren eine Nodetype -Aufzählung, um verschiedene Arten von Agentenknoten zu klassifizieren: Eingabe, Prozess, Entscheidung und Ausgabe. Wenn wir dann einen DataClass AgentNode verwenden, strukturieren wir jeden Knoten mit einer ID, einem Typ, einer Eingabeaufforderung, einer optionalen Funktion und einer Liste von Abhängigkeiten, sodass wir ein modulares und flexibles Agentendiagramm erstellen können.
def create_research_agent():
agent = GraphAgent()
# Enter node
agent.add_node(AgentNode(
id="topic_input",
sort=NodeType.INPUT,
immediate="Analysis matter enter"
))
agent.add_node(AgentNode(
id="research_plan",
sort=NodeType.PROCESS,
immediate="Create a complete analysis plan for the subject. Embrace 3-5 key analysis questions and methodology.",
dependencies=("topic_input")
))
agent.add_node(AgentNode(
id="literature_review",
sort=NodeType.PROCESS,
immediate="Conduct an intensive literature evaluation. Establish key papers, theories, and present gaps in information.",
dependencies=("research_plan")
))
agent.add_node(AgentNode(
id="evaluation",
sort=NodeType.PROCESS,
immediate="Analyze the analysis findings. Establish patterns, contradictions, and novel insights.",
dependencies=("literature_review")
))
agent.add_node(AgentNode(
id="quality_check",
sort=NodeType.DECISION,
immediate="Consider analysis high quality. Is the evaluation complete? Are there lacking views? Return 'APPROVED' or 'NEEDS_REVISION' with causes.",
dependencies=("evaluation")
))
agent.add_node(AgentNode(
id="final_report",
sort=NodeType.OUTPUT,
immediate="Generate a complete analysis report with govt abstract, key findings, and suggestions.",
dependencies=("quality_check")
))
return agentWir erstellen einen Forschungsagenten, indem wir dem Diagramm nacheinander spezialisierte Knoten hinzufügen. Ausgehend von einem Themeneingang definieren wir einen Prozessfluss, der Planung, Literaturübersicht und Analyse umfasst. Der Agent trifft dann eine Qualitätsentscheidung auf der Grundlage der Studie und erstellt schließlich einen umfassenden Forschungsbericht, in dem der gesamte Lebenszyklus eines strukturierten Forschungsworkflows erfasst wird.
Schauen Sie sich das an Codes.
def create_problem_solver():
agent = GraphAgent()
agent.add_node(AgentNode(
id="problem_input",
sort=NodeType.INPUT,
immediate="Drawback assertion"
))
agent.add_node(AgentNode(
id="problem_analysis",
sort=NodeType.PROCESS,
immediate="Break down the issue into elements. Establish constraints and necessities.",
dependencies=("problem_input")
))
agent.add_node(AgentNode(
id="solution_generation",
sort=NodeType.PROCESS,
immediate="Generate 3 completely different answer approaches. For every, clarify the methodology and anticipated outcomes.",
dependencies=("problem_analysis")
))
agent.add_node(AgentNode(
id="solution_evaluation",
sort=NodeType.DECISION,
immediate="Consider every answer for feasibility, value, and effectiveness. Rank them and choose the most effective method.",
dependencies=("solution_generation")
))
agent.add_node(AgentNode(
id="implementation_plan",
sort=NodeType.OUTPUT,
immediate="Create an in depth implementation plan with timeline, assets, and success metrics.",
dependencies=("solution_evaluation")
))
return agentWir erstellen einen Problemslösungsmittel, indem wir eine logische Folge von Knoten definieren, beginnend mit der Empfang der Problemanweisung. Der Agent analysiert das Drawback, erzeugt mehrere Lösungsansätze, bewertet sie anhand von Machbarkeit und Effektivität und schließt mit der Erstellung eines strukturierten Implementierungsplans, wodurch die automatisierte, schrittweise Auflösung des Issues ermöglicht wird.
Schauen Sie sich das an Codes.
def run_research_demo():
"""Run the analysis agent demo"""
print("🚀 Superior Graph Agent Framework Demo")
print("=" * 50)
research_agent = create_research_agent()
print("n📊 Analysis Agent Graph Construction:")
research_agent.visualize()
print("n🔍 Executing Analysis Job...")
research_agent.outcomes("topic_input") = "Synthetic Intelligence in Healthcare"
execution_order = checklist(nx.topological_sort(research_agent.graph))
for node_id in execution_order:
if node_id == "topic_input":
proceed
context = {}
node = research_agent.nodes(node_id)
if node.dependencies:
for dep in node.dependencies:
context(dep) = research_agent.outcomes.get(dep, "")
immediate = node.immediate
if context:
context_str = "n".be a part of((f"{ok}: {v}" for ok, v in context.gadgets()))
immediate = f"Context:n{context_str}nnTask: {immediate}"
strive:
response = research_agent.mannequin.generate_content(immediate)
end result = response.textual content.strip()
research_agent.outcomes(node_id) = end result
print(f"✓ {node_id}: {end result(:100)}...")
besides Exception as e:
research_agent.outcomes(node_id) = f"Error: {str(e)}"
print(f"✗ {node_id}: Error - {str(e)}")
print("n📋 Analysis Outcomes:")
for node_id, end in research_agent.outcomes.gadgets():
print(f"n{node_id.higher()}:")
print("-" * 30)
print(end result)
return research_agent.outcomes
def run_problem_solver_demo():
"""Run the issue solver demo"""
print("n" + "=" * 50)
problem_solver = create_problem_solver()
print("n🛠️ Drawback Solver Graph Construction:")
problem_solver.visualize()
print("n⚙️ Executing Drawback Fixing...")
problem_solver.outcomes("problem_input") = " cut back carbon emissions in city transportation"
execution_order = checklist(nx.topological_sort(problem_solver.graph))
for node_id in execution_order:
if node_id == "problem_input":
proceed
context = {}
node = problem_solver.nodes(node_id)
if node.dependencies:
for dep in node.dependencies:
context(dep) = problem_solver.outcomes.get(dep, "")
immediate = node.immediate
if context:
context_str = "n".be a part of((f"{ok}: {v}" for ok, v in context.gadgets()))
immediate = f"Context:n{context_str}nnTask: {immediate}"
strive:
response = problem_solver.mannequin.generate_content(immediate)
end result = response.textual content.strip()
problem_solver.outcomes(node_id) = end result
print(f"✓ {node_id}: {end result(:100)}...")
besides Exception as e:
problem_solver.outcomes(node_id) = f"Error: {str(e)}"
print(f"✗ {node_id}: Error - {str(e)}")
print("n📋 Drawback Fixing Outcomes:")
for node_id, end in problem_solver.outcomes.gadgets():
print(f"n{node_id.higher()}:")
print("-" * 30)
print(end result)
return problem_solver.outcomes
print("🎯 Operating Analysis Agent Demo:")
research_results = run_research_demo()
print("n🎯 Operating Drawback Solver Demo:")
problem_results = run_problem_solver_demo()
print("n✅ All demos accomplished efficiently!")Wir schließen das Tutorial mit zwei leistungsstarken Demo-Agenten ab, einen für Forschung und eine zur Problemlösung. In jedem Fall visualisieren wir die Graphenstruktur, initialisieren die Eingabe und führen die Agentenknoten für Node mithilfe einer topologischen Reihenfolge aus. Mit der Erzeugung von Gemini-Erzeugung kontextbezogener Reaktionen in jedem Schritt beobachten wir, wie jeder Agent autonom durch Planung, Analyse, Entscheidungsfindung und Output-Erzeugung fortschreitet und letztendlich das volle Potenzial unseres graphischen Rahmens zeigt.
Zusammenfassend haben wir intelligente Agenten, die Aufgaben schrittweise aufbrochen und gelöst haben, erfolgreich entwickelt und ausgeführt, wobei wir eine graphgesteuerte Architektur verwenden. Wir sehen, wie jeder Knoten kontextabhängige Eingabeaufforderungen verarbeitet, die Funktionen von Gemini für die Inhaltsgenerierung nutzt und die Ergebnisse an nachfolgende Knoten übergeben. Dieses modulare Design verbessert die Flexibilität und ermöglicht es uns auch, den logischen Fluss klar zu visualisieren.
Schauen Sie sich das an Codes. Alle Krediten für diese Forschung gilt an die Forscher dieses Projekts. Jetzt abonnieren zu unserem KI -Publication
Asif Razzaq ist der CEO von Marktechpost Media Inc. Sein jüngstes Bestreben ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch die ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die von einem breiten Publikum technisch intestine und leicht verständlich sind. Die Plattform verfügt über über 2 Millionen monatliche Ansichten und veranschaulicht ihre Beliebtheit des Publikums.
