Neuron Planner / uitvoerder

Bekijken als Markdown Bewerken op GitHub Documentatie op 2cc7b2b

In dit voorbeeld wordt Queuety gebruikt voor de orkestratie en Neuron voor de daadwerkelijke agentuitvoering.

Het patroon is eenvoudig. Een plannerstap van Queuety bepaalt welk werk er is, start_agents() zet die taken om in zelfstandige workflows op het hoogste niveau, elke onderliggende workflow voert een agent van Neuron uit en wait_for_agents() voegt de resultaten samen in de bovenliggende workflow.

Waarom deze verdeling goed werkt

Neuron is geschikt om met minimale codewijzigingen van provider te wisselen en de prompt, tools en het geheugen van een gespecialiseerde agent in te kapselen. Queuety is geschikt voor duurzame for-each- en voltooiingsmodi, nieuwe pogingen, hervatbaarheid en inspectie- of beoordelingsmogelijkheden voor de uitvoering.

Stap 1: maak een agent van Neuron waarvan u van provider kunt wisselen

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.',
            ],
        );
    }
}

Het handige hier is dat de workflow tijdens uitvoering een provider kan kiezen door provider mee te geven in de workflowstatus.

Stap 2: voer de agent van Neuron uit binnen een stap van Queuety

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 [];
    }
}

Dit is het belangrijkste integratiepunt: Neuron verzorgt de LLM-aanroep, maar Queuety beheert nog steeds de stapgrens en de opgeslagen workflowstatus.

Stap 3: laat de planner agentruns starten

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',
    ]);

Als PlanResearchTasksStep het volgende retourneert:

PHP

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

Queuety maakt één workflow op hoofdniveau per taak, wacht tot ze allemaal zijn voltooid en geeft daarna de voltooide status van de onderliggende workflow door onder $state['agent_results'].

Waarom Neuron niet gewoon in een lus aanroepen?

Dat kan, maar dan verlies je de voordelen van orkestratie:

Elke agentrun is dan niet meer afzonderlijk te inspecteren, een gedeeltelijke crash leidt waarschijnlijk tot het opnieuw starten van de hele batch en er is geen duidelijk voltooiingsmoment voor latere fasen.

Dit patroon houdt de agentcode eenvoudig en laat Queuety de duurzame orkestratie beheren.

Als de planner bij een agentsessie hoort die langer duurt, behoud dan dit workflowpatroon voor de uitvoeringslaag en laat een statusmachine de volledige levenscyclus beheren.