Neuron Hukommelse og tilstandsmaskine til gennemgang

Vis som Markdown Rediger på GitHub Dokumentation hos 2cc7b2b

Dette mønster er nyttigt, når en agent skal bevare samtalekonteksten gennem gentagne runder med menneskelig gennemgang, mens den overordnede livscyklus stadig styres af Queuety.

Queuety styrer tilstandsmaskinen for gennemgang, mens Neuron styrer agentens hukommelse for skriveforløbet.

Hvorfor Neuron-hukommelse er nyttig her

Hvis en kontrollør afviser et udkast og beder om ændringer, bør det næste agentkald ikke skulle genskabe hele konteksten fra bunden.

Neuron's SQLChatHistory egner sig godt til dette, fordi agenten kan fortsætte i den samme samtaletråd, mens Queuety håndterer kontrollørens beslutninger og revisionsrunder.

Agenten Neuron med historik baseret på SQL

PHP

namespace App\Neuron;

use NeuronAI\Agent\Agent;
use NeuronAI\Chat\History\ChatHistoryInterface;
use NeuronAI\Chat\History\SQLChatHistory;
use NeuronAI\Providers\AIProviderInterface;
use NeuronAI\Providers\Anthropic\Anthropic;
use NeuronAI\SystemPrompt;

final class EditorAgent extends Agent
{
    public function __construct(
        private readonly string $threadId,
        private readonly \PDO $pdo,
    ) {}

    protected function provider(): AIProviderInterface
    {
        return new Anthropic(
            key: $_ENV['ANTHROPIC_API_KEY'],
            model: $_ENV['ANTHROPIC_MODEL'],
        );
    }

    protected function chatHistory(): ChatHistoryInterface
    {
        return new SQLChatHistory(
            thread_id: $this->threadId,
            pdo: $this->pdo,
            table: 'neuron_chat_history',
            contextWindow: 50000,
        );
    }

    public function instructions(): string
    {
        return (string) new SystemPrompt(
            background: [
                'You are an editorial agent for long-form product briefs.',
                'Apply reviewer notes without losing the original intent.',
            ],
        );
    }
}

Skriv et udkast én gang, og revider det med den samme hukommelsestråd

PHP

namespace App\StateMachines\Actions;

use App\Neuron\EditorAgent;
use NeuronAI\Chat\Messages\UserMessage;
use Queuety\Contracts\StateAction;

final class DraftBriefAction implements StateAction
{
    public function handle(array $state, ?string $event = null, array $event_payload = [], array $payload = []): array|string
    {
        // Queuety creates actions with `new DraftBriefAction()`, so build dependencies here.
        $pdo = new \PDO($_ENV['NEURON_DB_DSN'], $_ENV['NEURON_DB_USER'], $_ENV['NEURON_DB_PASSWORD']);

        $threadId = $state['neuron_thread_id'] ?? sprintf(
            'brief:%d:editor',
            $state['brief_id'],
        );

        $prompt = "Write the first draft for brief {$state['brief_id']}.";

        if ('reject' === $event) {
            $prompt = sprintf(
                'Revise the draft using these review notes: %s',
                $event_payload['reason'] ?? 'Tighten the draft and address reviewer concerns.',
            );
        }

        $agent = new EditorAgent($threadId, $pdo);
        $message = $agent->chat(
            new UserMessage($prompt)
        )->getMessage();

        return [
            'neuron_thread_id' => $threadId,
            'draft_markdown' => $message->getContent(),
            'review_round' => (int) ($state['review_round'] ?? 0) + 1,
            '_event' => 'draft_ready',
        ];
    }
}

Tilstandsmaskinen Queuety

PHP

use Queuety\Enums\StateMachineStatus;
use Queuety\Queuety;

$machine_id = Queuety::machine('brief_review_session')
    ->version('brief-review-session.v1')
    ->state('drafting')
    ->action(DraftBriefAction::class)
    ->on('draft_ready', 'awaiting_review')
    ->state('awaiting_review')
    ->on('approve', 'completed')
    ->on('reject', 'drafting')
    ->state('completed', StateMachineStatus::Completed)
    ->dispatch([
        'brief_id' => 42,
    ]);

// Later, once the draft action has finished and the machine waits in `awaiting_review`:
Queuety::machine_event(
    $machine_id,
    'reject',
    [ 'reason' => 'Tighten the introduction and add pricing context.' ]
);

Queuety::machine_event(
    $machine_id,
    'approve',
    [ 'reviewer' => 'editor@example.com' ]
);

Første gennemløb går ind i drafting, udfører den kølagte handling og skifter derefter til awaiting_review.

Hvis kontrolløren afviser udkastet, går maskinen tilbage til drafting. Da hændelsens payload reject sendes til DraftBriefAction, kan det næste udkast bruge kontrollørens noter uden at miste historikken fra den oprindelige Neuron-tråd.

Hvorfor dette er enklere end at gentage et workflow

Dette problem handler om livscyklussen. Et udkast afventer menneskelig gennemgang, en kontrollør kan godkende eller afvise det, en afvisning sender sessionen tilbage til udarbejdelse, og en godkendelse afslutter sessionen. Det passer bedre til en tilstandsmaskine end til et lineært workflow med en tilbagekobling.

Workflowtilstand er stadig velegnet til orkestreringsdata som antal gennemgangsrunder, artefakt-id'er, workflow-id'er og beslutninger om routing. Neuron-hukommelse er bedre til samtalekontekst som tidligere prompts, løbende revisioner og modelsvar, der bør forblive en del af skriveforløbet.

Når de bruges sammen, får hvert system den opgave, det egner sig bedst til.

Hvornår dette i stedet bør forblive et workflow

Foretræk et workflow, når gennemgangsforløbet er klart afgrænset og handlingsorienteret, for eksempel:

Opret ét udkast, afvent én godkendelse, og udgiv det.

Foretræk en tilstandsmaskine, når sessionen kan vende tilbage til de samme tilstande flere gange, og eksterne hændelser styrer livscyklussen.