# Neuron mälu ja ülevaatuse olekumasin

See muster on kasulik, kui agent peab säilitama vestluse konteksti korduvate inimeste ülevaatusvoorude jooksul, kuid üldist elutsüklit peaks endiselt orkestreerima Queuety.

Queuety haldab ülevaatuse olekumasinat, samal ajal kui Neuron haldab mustandi vestluslõime agendimälu.

## Miks on Neuron mälu siin kasulik

Kui ülevaataja lükkab mustandi tagasi ja palub seda muuta, ei peaks järgmine agendikutse kogu konteksti uuesti looma.

Neuron `SQLChatHistory` sobib selleks hästi, sest agent saab jätkata samas vestluslõimes, samal ajal kui Queuety suunab ülevaataja otsuseid ja muudatusvoore.

## Neuron agent, mille ajalugu põhineb SQL-il

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

## Kirjutage mustand korra ja muutke seda sama mälulõime abil

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

## Queuety olekumasin

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

Esimene läbimine siseneb olekusse `drafting`, käivitab järjekorras oleva toimingu ja liigub seejärel olekusse `awaiting_review`.

Kui ülevaataja lükkab mustandi tagasi, liigub masin tagasi olekusse `drafting`. Kuna sündmuse `reject` andmed edastatakse `DraftBriefAction`-ile, saab järgmises mustandis kasutada ülevaataja märkusi, kaotamata algse Neuron lõime ajalugu.

## Miks see on töövoo kordusest selgem lahendus

See probleem puudutab elutsüklit. Mustand ootab inimese ülevaatust, ülevaataja saab selle heaks kiita või tagasi lükata, tagasilükkamine viib seansi tagasi mustandi koostamise juurde ja heakskiit lõpetab seansi. See sobitub olekumasinaga paremini kui tagasisuunaga lineaarse töövooga.

Töövoo olek sobib endiselt hästi orkestreerimise faktide jaoks, nagu ülevaatusvoorude arv, artefaktide ID-d, töövoo ID-d ja suunamisotsused. Neuron mälu sobib paremini vestluskonteksti jaoks, nagu varasemad viibad, korduvad muudatused ja mudeli vastused, mis peaksid jääma mustandi koostamise lõime osaks.

Mõlemat kasutades saab kumbki süsteem teha seda, milles ta kõige tugevam on.

## Millal kasutada selle asemel töövoogu

Eelistage töövoogu, kui ülevaatusprotsess on selgelt piiritletud ja täitmisele suunatud, näiteks:

Koostage üks mustand, oodake üht heakskiitu ja avaldage see.

Eelistage olekumasinat, kui seanss võib samu olekuid mitu korda läbida ja elutsüklit juhivad välised sündmused.

## Seotud dokumentatsioon

- [Olekumasinad](https://queuety.inline0.dev/et/docs/state-machines)
- [Töövoo signaalid](https://queuety.inline0.dev/et/docs/workflows/signals)
- [Agentide orkestreerimine](https://queuety.inline0.dev/et/docs/workflows/agent-orchestration)