Treci la conținut

Neuron Memorie + mașină de stări pentru revizuire

Vizualizați ca Markdown Editați pe GitHub Documentație la 2cc7b2b

Acest model este util când un agent trebuie să păstreze contextul conversației între mai multe sesiuni de revizuire umană, iar ciclul de viață general trebuie totuși orchestrat de Queuety.

Queuety gestionează mașina de stări pentru revizuire, iar Neuron gestionează memoria agentului pentru firul de redactare.

De ce este utilă aici memoria Neuron

Dacă un evaluator respinge o versiune și cere modificări, următorul apel al agentului nu ar trebui să fie nevoit să reconstruiască întregul context de la zero.

Neuron's SQLChatHistory se potrivește bine aici, deoarece agentul poate continua să lucreze în același fir de conversație, în timp ce Queuety direcționează deciziile evaluatorului și sesiunile de revizuire.

Agentul Neuron cu istoric bazat pe 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.',
            ],
        );
    }
}

Redactați o dată, revizuiți folosind același fir de memorie

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

Mașina de stări 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' ]
);

Prima iterație intră în drafting, execută acțiunea pusă în coadă și trece în awaiting_review.

Dacă evaluatorul respinge versiunea, mașina revine în drafting. Deoarece payloadul evenimentului reject este transmis către DraftBriefAction, următoarea versiune poate folosi observațiile evaluatorului fără să piardă istoricul firului original Neuron.

De ce este mai simplu decât repetarea unui flux de lucru

Această problemă ține de ciclul de viață. O versiune așteaptă revizuirea umană, evaluatorul o poate aproba sau respinge, respingerea readuce sesiunea la redactare, iar aprobarea încheie sesiunea. Acest lucru se modelează mai direct cu o mașină de stări decât cu un flux de lucru liniar care revine la un pas anterior.

Starea fluxului de lucru rămâne excelentă pentru fapte de orchestrare, precum numărul sesiunii de revizuire, ID-urile artefactelor, ID-urile fluxurilor de lucru și deciziile de rutare. Memoria Neuron este mai potrivită pentru contextul conversației, precum prompturile anterioare, revizuirile iterative și răspunsurile modelului care trebuie să rămână parte din firul de redactare.

Folosirea ambelor le permite fiecărui sistem să facă ceea ce știe cel mai bine.

Când să păstrați această abordare ca flux de lucru

Alegeți un flux de lucru când traseul de revizuire este bine delimitat și orientat spre execuție, de exemplu:

Generați o versiune, așteptați o aprobare și publicați-o.

Alegeți o mașină de stări când sesiunea poate reveni de mai multe ori la aceleași stări, iar evenimentele externe îi determină ciclul de viață.