0Pricing
AI Engineering Academy · Lekcja

Samokorekta i refleksyjne promptowanie

Zaimplementuj etap refleksji, w którym agent porównuje własne dane wyjściowe z pierwotnym celem, identyfikuje braki lub błędy i generuje poprawiony plan przed ponowną próbą.

Samokorekta i refleksyjne promptowanie to bezpłatna lekcja AI Engineering Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Engineering Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Engineering Academy zawiera 4 lekcji w sumie.

Czym jest refleksyjne tworzenie promptów

Refleksyjne tworzenie promptów to technika, w której prosi się agenta o ocenę własnego wyniku przed jego zatwierdzeniem. Zamiast wygenerować odpowiedź i zakończyć działanie, agent porównuje ją z pierwotnym celem, identyfikuje braki lub błędy i tworzy poprawioną wersję. Przypomina to korektę własnej pracy przez człowieka i znacznie poprawia jakość wyników w złożonych zadaniach bez konieczności używania oddzielnego modelu krytyka.

Pętla refleksji i poprawiania

Podstawowa pętla refleksyjna składa się z trzech kroków: Wygeneruj wstępną odpowiedź, Skrytykuj ją według jasno określonych kryteriów i Popraw na podstawie krytyki. Pętlę można wykonać raz lub wielokrotnie. Każda iteracja ulepsza odpowiedź, aż krytyka uzna ją za zadowalającą albo zostanie osiągnięta maksymalna liczba poprawek. Sam etap krytyki jest wywołaniem LLM ze specjalistycznym promptem refleksyjnym.

async def reflect_and_revise(task: str, max_rounds: int = 2) -> str:
    response = await generate_initial(task)
    for round_num in range(max_rounds):
        critique = await critique_response(task, response)
        if critique.is_satisfactory:
            break
        response = await revise_response(task, response, critique.feedback)
    return response

Pisanie skutecznego promptu krytykującego

Prompt krytykujący musi określać konkretne kryteria oceny, zamiast po prostu prosić model o „ulepszenie” odpowiedzi. Należy wymienić konkretne elementy do sprawdzenia: Czy każde twierdzenie jest poprawne? Czy odpowiedź obejmuje wszystkie części pytania? Czy brakuje jakiegoś kroku? Czy zawiera zbędne rozwinięcia? Prompt krytykujący z jawną listą kontrolną dostarcza użytecznych informacji zwrotnych, które etap poprawiania może bezpośrednio wykorzystać.

CRITIQUE_PROMPT = '''
You are reviewing an AI-generated response to this task: {task}

Response to evaluate:
{response}

Check each criterion and provide specific feedback:
1. COMPLETENESS: Does it address all parts of the task?
2. ACCURACY: Are all factual claims correct?
3. CONCISENESS: Is there unnecessary padding or repetition?
4. FORMAT: Does it match the requested output format?
5. ACTIONABILITY: Can the user act on this response?

For each issue found, state exactly what to fix.
If the response is satisfactory on all criteria, say APPROVE.
'''

Analizowanie odpowiedzi krytykującej

Ustrukturyzuj wynik krytyki jako model Pydantic, aby można było programowo zdecydować, czy należy wprowadzić poprawki. Pole is_satisfactory określa, czy zakończyć pętlę. Lista issues dokładnie wskazuje etapowi poprawiania, co należy naprawić. Pole severity pozwala pominąć poprawianie w przypadku drobnych problemów stylistycznych, a jednocześnie zawsze wprowadzać poprawki w razie błędów merytorycznych.

from pydantic import BaseModel
from typing import List, Literal

class Issue(BaseModel):
    criterion: str
    description: str
    severity: Literal['critical', 'moderate', 'minor']

class Critique(BaseModel):
    is_satisfactory: bool
    issues: List[Issue]
    overall_verdict: str

# is_satisfactory=True means no revision needed
# is_satisfactory=False means issues must be addressed

Monit poprawiający

Monit poprawiający otrzymuje pierwotne zadanie, początkową odpowiedź oraz informacje zwrotne z krytyki. Należy poprosić model o przygotowanie ulepszonej wersji, która odnosi się konkretnie do każdego problemu wskazanego w krytyce, zachowując jednocześnie poprawne części pierwotnej odpowiedzi. Zawsze należy uwzględnić słowo „only”, aby uniemożliwić modelowi wprowadzanie zbędnych zmian w elementach, które krytyka już zaakceptowała.

def build_revision_prompt(task: str, response: str, critique: Critique) -> str:
    issues_text = '\n'.join(
        f'- [{i.severity.upper()}] {i.criterion}: {i.description}'
        for i in critique.issues
    )
    return f'''
Original task: {task}

Your previous response:
{response}

Issues to fix:
{issues_text}

Write an improved response that fixes ONLY the issues listed above.
Do not change parts that were not flagged as problems.
'''

Samokorekta podczas generowania kodu

Samokorekta jest szczególnie skuteczna podczas generowania kodu. Po wygenerowaniu kodu uruchom linter lub narzędzie do sprawdzania typów, przekaż modelowi wynik z błędami i poproś go o ich naprawienie. Taka refleksja oparta na wykonaniu jest bardziej niezawodna niż krytyka oparta wyłącznie na języku, ponieważ informacje zwrotne pochodzą z obiektywnego narzędzia, a nie z oceny innego LLM.

import subprocess
import sys

async def self_correct_code(task: str, max_rounds: int = 3) -> str:
    code = await generate_code(task)
    for _ in range(max_rounds):
        # Write code to temp file and run mypy
        with open('/tmp/agent_code.py', 'w') as f:
            f.write(code)
        result = subprocess.run(
            [sys.executable, '-m', 'mypy', '/tmp/agent_code.py', '--ignore-missing-imports'],
            capture_output=True, text=True
        )
        if result.returncode == 0:
            break  # No type errors
        code = await fix_code(code, result.stdout + result.stderr)
    return code

Unikanie nadmiernych poprawek

Częstym problemem systemów refleksyjnych jest nadmierne poprawianie: model, próbując naprawić jedną rzecz, pogarsza pierwotny problem. Można temu przeciwdziałać, ograniczając zakres poprawek: monit poprawiający powinien wyraźnie informować, aby „do not change anything that was not flagged”. Należy także porównać poprawioną odpowiedź z oryginałem za pomocą sprawdzenia różnic — jeśli poprawiona wersja znacząco się różni, coś poszło nie tak i należy zachować oryginał.

from difflib import SequenceMatcher

def safe_revision(original: str, revised: str, max_change_ratio: float = 0.7) -> str:
    similarity = SequenceMatcher(None, original, revised).ratio()
    if similarity < (1 - max_change_ratio):
        print(f'Revision changed too much (similarity: {similarity:.2f}). Keeping original.')
        return original
    return revised

Refleksja w zadaniach agentów wieloetapowych

W agencie wieloetapowym dodaj punkt kontrolny refleksji po ukończeniu określonego zestawu kroków — na przykład po zebraniu wszystkich materiałów, ale przed napisaniem raportu końcowego. Agent przegląda zebrane informacje, identyfikuje braki i decyduje, czy zebrać więcej danych, czy kontynuować. Taka refleksja w trakcie zadania zapobiega przejściu agentów do etapu syntezy z niepełnymi lub sprzecznymi dowodami.

async def research_with_reflection(question: str) -> str:
    # Phase 1: gather evidence
    evidence = await gather_evidence(question)

    # Reflection checkpoint
    assessment = await assess_evidence_completeness(question, evidence)
    if not assessment.is_complete:
        for gap in assessment.gaps:
            more_evidence = await targeted_search(gap.search_query)
            evidence.extend(more_evidence)

    # Phase 2: synthesize
    return await synthesize_answer(question, evidence)

Rejestrowanie wyników refleksji

Rejestruj każdą rundę refleksji: oceny z krytyki, zidentyfikowane problemy oraz informację, czy poprawka rzeczywiście je rozwiązała. Dane te pokazują, czy monity refleksyjne są skuteczne. Jeśli poprawiona odpowiedź regularnie ponownie zawiera te same problemy wskazane w krytyce, monit poprawiający nie jest wystarczająco szczegółowy. Jeśli większość krytyk kończy się wynikiem „APPROVE” już w pierwszej rundzie, jakość początkowego generowania jest wysoka i narzut związany z refleksją może nie być wart poniesionego kosztu.

import structlog

log = structlog.get_logger()

def log_reflection_round(task_id: str, round_num: int, critique: Critique, action: str):
    log.info(
        'reflection_round',
        task_id=task_id,
        round=round_num,
        is_satisfactory=critique.is_satisfactory,
        issue_count=len(critique.issues),
        critical_issues=sum(1 for i in critique.issues if i.severity == 'critical'),
        action=action  # 'approved', 'revised', 'max_rounds_reached'
    )

Kiedy stosować refleksję

Refleksja zwiększa opóźnienie i koszt — dwuetapowy proces refleksji i poprawiania co najmniej trzykrotnie zwiększa liczbę wywołań LLM dla danego zadania. Stosuj refleksję wybiórczo: zawsze w przypadku wyników o dużym znaczeniu (kodu, który zostanie uruchomiony, oraz odpowiedzi na istotne pytania biznesowe), opcjonalnie w przypadku odpowiedzi widocznych dla użytkownika i nigdy w przypadku wewnętrznych kroków pośrednich, które narzędzie natychmiast zweryfikuje. Koszt jest uzasadniony, gdy jakość ma większe znaczenie niż szybkość.

# Reflection decision matrix:
# Task type:              Use reflection?
# SQL query generation    YES (run+verify)
# Final report writing    YES (review before delivery)
# Tool argument prep      NO  (tool result verifies it)
# Short factual answer    MAYBE (if accuracy is critical)
# Internal agent thought  NO   (intermediate, not final)
# Code generation         YES  (run linter/tests)

USE_REFLECTION = {'report', 'code', 'email', 'analysis'}

Pomiar skuteczności refleksji

Sprawdzaj, czy refleksja rzeczywiście poprawia wyniki, przeprowadzając testy A/B: przetwarzaj losowo 50% zadań z refleksją, a 50% bez niej, a następnie oceń oba zbiory za pomocą sędziego LLM. Jeśli grupa z refleksją uzyska istotnie wyższe wyniki, a poprawa przewyższy dodatkowe opóźnienie i koszt, refleksja przynosi korzyści. Jeśli wyniki będą podobne, jakość początkowego generowania jest już wystarczająco wysoka, a refleksja zwiększa narzut bez dodatkowych korzyści.

async def reflection_ab_test(tasks: list) -> dict:
    import random
    results = {'with_reflection': [], 'without_reflection': []}
    for task in tasks:
        if random.random() < 0.5:
            response = await reflect_and_revise(task, max_rounds=2)
            group = 'with_reflection'
        else:
            response = await generate_initial(task)
            group = 'without_reflection'
        score = await judge(task, response)
        results[group].append(score.overall)
    return {
        'mean_with': sum(results['with_reflection']) / len(results['with_reflection']),
        'mean_without': sum(results['without_reflection']) / len(results['without_reflection'])
    }

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat samokorekty i monitów refleksyjnych w agentach.

Podsumowanie lekcji

W tej lekcji poznano: pętle refleksji i poprawiania, które podnoszą jakość wyników, ponieważ agent krytykuje i poprawia własne odpowiedzi; konkretne kryteria krytyki, które dostarczają użytecznych informacji zwrotnych zamiast ogólnych sugestii ulepszeń; oraz refleksję opartą na wykonaniu z użyciem obiektywnych narzędzi, takich jak lintery, która jest szczególnie skuteczna podczas generowania kodu. Następnie zaimplementujemy tworzenie punktów kontrolnych agenta i wznawianie zadań.

Często zadawane pytania

Czy lekcja „Samokorekta i refleksyjne promptowanie” jest bezpłatna?

Tak — pełny tekst „Samokorekta i refleksyjne promptowanie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Engineering Academy, przejdź na CoddyKit PRO. Kurs AI Engineering Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Samokorekta i refleksyjne promptowanie”?

Zaimplementuj etap refleksji, w którym agent porównuje własne dane wyjściowe z pierwotnym celem, identyfikuje braki lub błędy i generuje poprawiony plan przed ponowną próbą. Ćwiczysz AI Engineering Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Engineering Academy?

Nie wymagamy żadnego doświadczenia. AI Engineering Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Samokorekta i refleksyjne promptowanie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Engineering Academy?

Tak. Każda lekcja AI Engineering Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Klasyfikowanie trybów awarii agentów
  2. Samokorekta i refleksyjne promptowanie
  3. Punkty kontrolne i wznawianie zadań
  4. Eskalacja z udziałem człowieka
← Powrót do AI Engineering Academy