Zum Inhalt springen

Neuron Planer / Ausführer

Als Markdown anzeigen Auf GitHub bearbeiten Dokumentation zu 2cc7b2b

Dieses Beispiel verwendet Queuety für die Orchestrierung und Neuron für die eigentliche Agentenausführung.

Das Muster ist einfach: Ein Queuety-Planungsschritt legt fest, welche Aufgaben anfallen; start_agents() macht daraus unabhängige Workflows auf oberster Ebene; jeder untergeordnete Workflow führt einen Neuron-Agenten aus, und wait_for_agents() führt die Ergebnisse wieder im übergeordneten Workflow zusammen.

Warum diese Aufteilung gut funktioniert

Neuron kann Anbieter mit minimalen Codeänderungen wechseln und Prompt, Tools und Speicher für einen spezialisierten Agenten bündeln. Queuety eignet sich für dauerhafte Modi zur Verarbeitung jedes Elements und zum Abschluss, Wiederholungen, Fortsetzungen sowie Prüfungsansichten für Ausführungen.

Schritt 1: Einen Neuron-Agenten mit wechselbarem Anbieter erstellen

PHP
namespace App\Neuron;

use NeuronAI\Agent\Agent;
use NeuronAI\Providers\AIProviderInterface;
use NeuronAI\Providers\Anthropic\Anthropic;
use NeuronAI\Providers\Gemini\Gemini;
use NeuronAI\Providers\OpenAI\Responses\OpenAIResponses;
use NeuronAI\SystemPrompt;

final class ResearchAgent extends Agent
{
    public function __construct(
        private readonly string $providerName = 'openai',
    ) {}

    protected function provider(): AIProviderInterface
    {
        return match ($this->providerName) {
            'anthropic' => new Anthropic(
                key: $_ENV['ANTHROPIC_API_KEY'],
                model: $_ENV['ANTHROPIC_MODEL'],
            ),
            'gemini' => new Gemini(
                key: $_ENV['GEMINI_API_KEY'],
                model: $_ENV['GEMINI_MODEL'],
            ),
            default => new OpenAIResponses(
                key: $_ENV['OPENAI_API_KEY'],
                model: $_ENV['OPENAI_MODEL'],
            ),
        };
    }

    public function instructions(): string
    {
        return (string) new SystemPrompt(
            background: [
                'You are a research agent.',
                'Return concise, source-aware summaries for the assigned topic.',
            ],
        );
    }
}

Nützlich ist hier, dass der Workflow den Anbieter zur Laufzeit auswählen kann, indem provider im Workflow-Zustand übergeben wird.

Schritt 2: Den Neuron-Agenten in einem Queuety-Schritt ausführen

PHP
namespace App\Workflow\Steps;

use App\Neuron\ResearchAgent;
use NeuronAI\Chat\Messages\UserMessage;
use Queuety\Step;

final class ResearchTopicStep implements Step
{
    public function handle(array $state): array
    {
        $agent = new ResearchAgent(
            providerName: $state['provider'] ?? 'openai',
        );

        $message = $agent->chat(
            new UserMessage(sprintf(
                "Research the topic '%s' for brief %d. Return a compact bullet summary.",
                $state['topic'],
                $state['brief_id'],
            ))
        )->getMessage();

        return [
            'summary' => $message->getContent(),
        ];
    }

    public function config(): array
    {
        return [];
    }
}

Das ist der entscheidende Integrationspunkt: Neuron übernimmt den LLM-Aufruf, aber Queuety verwaltet weiterhin die Schrittgrenze und den gespeicherten Workflow-Zustand.

Schritt 3: Den Planer Agentenläufe starten lassen

PHP
use Queuety\Enums\WaitMode;
use Queuety\Queuety;

$agent_workflow = Queuety::workflow('research_agent_run')
    ->then(ResearchTopicStep::class);

Queuety::workflow('brief_research')
    ->version('brief-research.v1')
    ->then(PlanResearchTasksStep::class) // writes $state['agent_tasks']
    ->start_agents('agent_tasks', $agent_workflow)
    ->wait_for_agents(mode: WaitMode::All, result_key: 'agent_results')
    ->then(SynthesizeBriefStep::class)
    ->dispatch([
        'brief_id' => 42,
        'provider' => 'anthropic',
    ]);

Wenn PlanResearchTasksStep Folgendes zurückgibt:

PHP
[
    'agent_tasks' => [
        ['topic' => 'pricing'],
        ['topic' => 'customer reviews'],
        ['topic' => 'recent launches'],
    ],
]

Queuety erstellt einen Workflow auf oberster Ebene pro Aufgabe, wartet, bis alle abgeschlossen sind, und übergibt dann den fertigen Zustand der untergeordneten Workflows unter $state['agent_results'].

Warum Neuron nicht einfach in einer Schleife aufrufen?

Das wäre möglich, aber du würdest die Vorteile der Orchestrierung verlieren:

Jeder Agentenlauf wäre nicht mehr einzeln prüfbar, bei einem teilweisen Absturz müsste wahrscheinlich der gesamte Stapel neu gestartet werden, und es gäbe keinen klaren Abschlusspunkt für spätere Phasen.

Dieses Muster hält den Agentencode einfach und überlässt Queuety die dauerhafte Orchestrierung.

Wenn der Planer zu einer länger laufenden Agentensitzung gehört, verwende dieses Workflow-Muster für die Ausführungsebene und lass eine Zustandsmaschine den äußeren Lebenszyklus steuern.