Praktyczne wskazówki: Podręcznik krok po kroku do rozwijania własnego agenta
Praktyczne wskazówki: Podręcznik krok po kroku do tworzenia własnego agenta – umowy, sprawdzenia oraz gotowe elementy kodu dla zespołów wdrażających ten wzorzec.
To przewodnictwo pokazuje, jak przejść od surowców do gotowego systemu w ramach: Krok po kroku – jak stworzyć swój osobisty system agenty. Skupia się na konkretnych krokach działania, jasnych sprawdzeniach oraz kodzie, który można bez problemu umieścić w repozytorium, nie musząc zgadywać jego przeznaczenia.
Tutoriale praktyczne
W fazie tutorieli praktycznych należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić dany krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu systemu. Konfigurację należy trzymać oddzielnie od kodu aplikacji – pliki środowiskowe, magazyny tajnych danych oraz flagi funkcjonalne powinny znajdować się w jednym miejscu, które operatorzy mogą sprawdzić, nie musząc czytać całej struktury systemu. Zatwierdzenie ludzkie powinno być wymagane przy operacjach, które wiążą się z wydawaniem pieniędzy lub modyfikacją danych produkcyjnych. Połączenia realizowane w czasie kompilacji nie gwarantują pełnej kompletności rozwiązania biznesowego.
Aby stworzyć kompletny przewodnik, zdefiniuj dane wejściowe, osobę odpowiedzialną za daną etap oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić daną etap na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Zdokumentuj zarówno prawidłowy przebieg działania, jak i ścieżkę naprawczą. Próby ponownych działań, kontrola przez człowieka oraz obsługa błędów stanowią część produktu, a nie elementy dodawane później. W przypadku, gdy następnym krokiem jest kod lub wywołanie narzędzia, preferuj strukturyzowane wyniki z walidacją schematu zamiast tekstów w formie swobodnej.
W fazie Wprowadzenie do mechanizmów agentowych należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić dany krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Należy preferować małe, testowalne jednostki nad rozbudowanymi skryptami. Gdy dany krok zawiedzie, powinien wskazywać na konkretną odpowiedzialność, a nie na skomplikowany łańcuch operacji. Konieczne jest ludzkie zatwierdzenie w przypadkach, gdy dochodzi do wydawania pieniędzy lub modyfikacji danych produkcyjnych. Połączenia realizowane w czasie kompilacji nie równają się kompletności rozwiązania biznesowego.
Wniosek 1: Twój LLM nie jest pisarzem; to procesor.
Dla etapu Takeaway 1 Your LLM należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić ten krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nazwij powstałe pliki, zdefiniuj kryteria sukcesu i odrzuć ciche, częściowe ukończenie zadania. Przy następnym kroku, który polega na pisaniu kodu lub wywoływaniu narzędzia, preferuj strukturyzowane wyniki z walidacją schematu zamiast tekstów w formie swobodnej.
Takeaway 2: Nie potrzebujesz kolejnych miliardów parametrów; potrzebujesz wyspecjalizowanej „zespołu agentów”.
Dla etapu Takeaway 2 You Don należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić ten krok od znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Zapisuj czas trwania oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy ścieżka przechodzi z środowiska demonstracyjnego do współdzielonych środowisk. Wprowadź ludzką aprobatę dla operacji, które generują wydatki lub zmieniają dane produkcyjne. Połączenia realizowane w czasie kompilacji nie gwarantują pełnej kompletności rozwiązania biznesowego. Dla etapu Takeaway 2 You Don należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić ten krok od znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Zdokumentuj zarówno ścieżkę prawidłowego działania, jak i ścieżkę naprawczą. Próby ponownych działań, ludzkie kontrolne punkty oraz obsługa wiadomości błędowych stanowią część produktu, a nie elementy dodawane później.
Rzeczywisty problem: Człowiek kontra maszyna.
Gdy przechodzisz przez etap „Rzeczywisty problem – Człowiek”, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Wolno preferować małe, testowalne jednostki zamiast rozbudowanych skryptów. Gdy jakiś krok się nie powiedzie, błąd powinien wskazywać na jedną konkretne odpowiedzialność, a nie na skomplikowany łańcuch operacji. Ustaw punkty kontrolne po kosztownych krokach. System powinien unikać ponownego pobierania opłat za tę samą funkcję LLM, gdy operator próbuje ponownie wykonać późniejszy element.
Dlaczego pojedyncze prompty zawodzą, a systemy agentowe działają.
Gdy przechodzisz przez etap „Dlaczego pojedyncze polecenia zawodzą”, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nadaj nazwy poszczególnym elementom, zdefiniuj kryteria sukcesu i odrzuć ciche, częściowe ukończenie zadania. Zachowuj w pamięci tymczasowej stabilne instrukcje systemu oraz schematy narzędzi. Ponowne wysyłanie identycznego nagłówka jest częstą przyczyną marnotrawstwa zasobów.
Czym jest architektura agenta?
Podczas prace nad etapem „Co to jest agent”, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Zapisz czas trwania operacji oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy proces przechodzi z środowiska demonstracyjnego do współdzielonych środowisk. Ustal punkty kontrolne po kosztownych krokach. System powrotu nie powinien ponownie naliczać opłat za tę samą wywołanie LLM, gdy operator próbuje ponownie uruchomić późniejszy węzeł. Podczas prace nad etapem „Co to jest agent”, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Zdokumentuj zarówno ścieżkę prawidłowego działania, jak i ścieżkę naprawczą. Próby ponownych wywołań, mechanizmy ludzkiej kontroli oraz obsługa wiadomości błędowych są częścią produktu, a nie elementem dodatkowej optymalizacji.
Pipeline Retrieval-Augmented Generation (RAG).
Etap pipeline Retrieval-Augmented Generation RAG funkcjonuje najlepiej, gdy traktowany jest jako mierzalna struktura. Zanim rozszerzysz zakres pracy, zapisz jeden idealny przykład transkrypcji, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia działań. Wolno preferować małe, łatwe do przetestowania jednostki zamiast rozbudowanych skryptów. Gdy jakiś krok zawiedzie, awaria powinna wskazywać na konkretną odpowiedzialność, a nie na skomplikowaną strukturę pipeline’u. Rozdziel politykę dzielenia na fragmenty od polityki wyszukiwania informacji. Zmiana jednej z nich nie powinna zmuszać do przepisywania drugiej, gdy zmieniają się metryki jakości.
Wyzwania systemów RAG
Wyzwania związane z etapem RAG działają najlepiej, gdy traktuje się je jako mierzalną powierzchnię do analizy. Zapisz jeden idealny przykład transkrypcji, jeden przypadek niepowodzenia oraz notatkę dotyczącą cofnięcia działań, zanim rozszerzysz zakres pracy. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nadaj nazwy poszczególnym elementom, zdefiniuj kryteria sukcesu i odrzucaj ciche, częściowe rozwiązania. Oddziel zasady dzielenia na fragmenty od zasad wyszukiwania informacji. Zmiana jednych nie powinna zmuszać do przepisywania drugich, gdy zmieniają się metryki jakości.
W procesie RAG wymagane są cztery kroki
Cztery kroki stanowią niezbędne etapy w procesie rozwoju, które działają najlepiej, gdy traktuje się je jako mierzalną powierzchnię do analizy. Zapisz jeden idealny przykład działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian przed rozszerzeniem zakresu pracy. Zarejestruj czasy wykonywania operacji oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy proces przechodzi z środowiska demonstracyjnego do współdzielonych środowisk. Rozdziel politykę dzielenia na fragmenty od polityki wyszukiwania. Zmiana jednej z nich nie powinna zmuszać do przepisywania drugiej, gdy zmieniają się metryki jakości. Cztery kroki stanowią niezbędne etapy w procesie rozwoju, które działają najlepiej, gdy traktuje się je jako mierzalną powierzchnię do analizy. Zapisz jeden idealny przykład działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian przed rozszerzeniem zakresu pracy. Zdokumentuj zarówno ścieżkę prawidłowego działania, jak i ścieżkę naprawczą. Próby ponownych działań, kontrolne punkty ludzkie oraz obsługa wiadomości błędowych są częścią produktu, a nie elementem dodatkowej obróbki później.
Ranking i agregacja fragmentów
Aby sklasyfikować i zsumować etapy, należy określić dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed modyfikacją kodu. Operatorzy powinni móc ponownie uruchomić dany krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Należy preferować małe, testowalne jednostki zamiast rozbudowanych skryptów. Gdy dany krok zawiedzie, powinien wskazywać na konkretną odpowiedzialność, a nie na skomplikowany łańcuch operacji. Konieczna jest ludzka akceptacja w przypadku operacji, które wiążą się z wydawaniem pieniędzy lub modyfikacją danych produkcyjnych. Połączenia realizowane w czasie kompilacji nie równają się kompletności biznesowej.
Ostatnim krokiem jest generowanie.
Na etapie Ostatniego kroku należy zdefiniować dane wejściowe, osobę odpowiedzialną za ten krok oraz kryteria zakończenia przed modyfikacją kodu. Operatorzy powinni móc ponownie uruchomić ten krok od znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nadaj nazwy poszczególnym elementom, zdefiniuj kryteria sukcesu i odrzuć ciche, częściowe ukończenie zadania. Wymagaj ludzkiej aprobaty w przypadkach, gdy dochodzi do wydawania pieniędzy lub modyfikacji danych produkcyjnych. Połączenia realizowane w czasie kompilacji nie równają się pełnej kompletności procesu biznesowego.
Zadania, które działają wyjątkowo dobrze przy użyciu tego pipeline’u.
W fazie „Zadania, które działają niezwykle dobrze” należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić ten krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Zapisuj czas trwania oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy ścieżka przechodzi z środowiska demonstracyjnego do współdzielonych środowisk. Wprowadź ludzką aprobatę dla operacji, które generują wydatki lub zmieniają dane produkcyjne. Podłączenia realizowane w czasie kompilacji nie gwarantują pełnej kompletności rozwiązania biznesowego. W fazie „Zadania, które działają niezwykle dobrze” należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić ten krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Dokumentuj zarówno ścieżkę prawidłowego działania, jak i ścieżkę naprawczą. Próby ponownych działań, ludzkie kontrolne punkty oraz obsługa wiadomości błędowych stanowią część produktu, a nie elementy dodawane później.
/p>Globalny proces rozumowania
Podczas pracy nad etapem Globalnego procesu rozumowania najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Wolno preferować małe, testowalne jednostki zamiast rozbudowanych skryptów. Gdy jakiś krok się nie powiedzie, błąd powinien wskazywać na konkretną odpowiedzialność, a nie na skomplikowany łańcuch operacji. Zachowuj w pamięci tymczasowej stabilne instrukcje systemu oraz schematy narzędzi. Ponowne wysyłanie identycznego nagłówka jest częstą przyczyną marnotrawstwa zasobów.
Dwuetapowa strategia globalnego rozumowania
Gdy przechodzisz przez etap Dwuetapowego Globalnego Rozumowania, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nadaj nazwy poszczególnym elementom, zdefiniuj kryteria sukcesu i odrzuć ciche, częściowe ukończenie zadania. Zachowuj w pamięci tymczasowej stabilne instrukcje systemu oraz schematy narzędzi. Ponowne wysyłanie identycznego prefiksu jest częstą przyczyną marnotrawstwa zasobów.
Ponowne formułowanie zapytań
Podczas przechodzenia przez etap przepisywania zapytań, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Zapisz czasy wykonywania oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy proces przechodzi z środowiska demonstracyjnego do współdzielonych środowisk. Ustal punkty kontrolne po kosztownych krokach. Narzędzie do kontynuacji nie powinno ponownie naliczać opłat za ten sam wywołanie LLM, gdy operator próbuje ponownie uruchomić późniejszy węzeł. Podczas przechodzenia przez etap przepisywania zapytań, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Zdokumentuj zarówno ścieżkę prawidłowego działania, jak i ścieżkę naprawczą. Próby ponownych wywołań, mechanizmy ludzkiej kontroli oraz obsługa wiadomości błędnych stanowią część produktu, a nie elementy dodatkowej optymalizacji.
Rozumowanie lokalne i globalne razem
Etap rozumowania lokalnego i globalnego działa najlepiej, gdy traktuje się go jako mierzalną powierzchnię. Zapisz jeden idealny przykład działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia działań, zanim rozszerzysz zakres pracy. Wolno preferować małe, testowalne jednostki zamiast rozbudowanych skryptów. Gdy jakiś krok zawiedzie, awaria powinna wskazywać na konkretną odpowiedzialność, a nie na skomplikowany łańcuch operacji. Określ budżet tokenów na jeden ruch i na jedną sesję. Narzędzia typu agentic intensywnie rozszerzają kontekst; sztywne limity zapobiegają temu, by demonstracje przerodziły się w nieoczekiwane rachunki.
Małe modele językowe wygrywają.
Małe modele językowe działają najlepiej na tym etapie, gdy traktuje się je jako mierzalną powierzchnię do analizy. Zapisz jeden idealny przykład działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia działań, zanim rozszerzysz zakres pracy. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nazwij poszczególne elementy, zdefiniuj kryteria sukcesu i odrzuć przypadki częściowego ukończenia pracy bez informacji. Przydziel budżet tokenów na każdy ruch i sesję. Narzędzia typu agentic intensywnie rozszerzają kontekst; sztywne limity zapobiegają temu, by demonstracje przerodziły się w nieoczekiwane rachunki.
Ustaw swojego własnego lokalnego modelu za pomocą LM Studio.
Faza „Ustaw swoje własne” funkcjonuje najlepiej, gdy jest traktowana jako powierzchnia poddawalna pomiarom. Zapisz jeden idealny przepis działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian, zanim rozszerzysz zakres pracy. Zapisuj czasy wykonywania operacji oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy przechodzi się od wersji demonstracyjnej do środowisk współdzielonych. Przydziel budżet tokenów na jeden ruch i na jedną sesję. Narzędzia typu agentic intensywnie rozszerzają kontekst; sztywne limity zapobiegają temu, by wersje demonstracyjne przerodziły się w niespodziewane rachunki. Faza „Ustaw swoje własne” funkcjonuje najlepiej, gdy jest traktowana jako powierzchnia poddawalna pomiarom. Zapisz jeden idealny przepis działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian, zanim rozszerzysz zakres pracy. Zdokumentuj zarówno optymalną ścieżkę działania, jak i ścieżkę naprawczą. Próby ponownych działań, kontrolne punkty ludzkie oraz obsługa wiadomości błędowych stanowią część produktu, a nie elementy dodawane później.
Biblioteka LLMlight.
Dla etapu The LLMlight Library należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić dany krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Należy preferować małe, testowalne jednostki zamiast rozbudowanych skryptów. Gdy dany krok zawiedzie, powód awarii powinien wskazywać na konkretną odpowiedzialność, a nie na skomplikowany łańcuch operacji. W przypadku, gdy następnym krokiem jest kod lub wywołanie narzędzia, lepsze są ustrukturyzowane wyniki z walidacją schematu niż tekst w formie swobodnej.
Strategia dzielenia na fragmenty
W fazie strategii dzielenia na fragmenty należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed modyfikacją kodu. Operatorzy powinni móc ponownie uruchomić ten krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Traktuj tę fazę jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nazwij poszczególne elementy, zdefiniuj kryteria sukcesu i odrzuć ciche, częściowe ukończenie zadania. Konieczna jest ludzka akceptacja w przypadku operacji, które wiążą się z wydawaniem pieniędzy lub modyfikacją danych produkcyjnych. Połączenia realizowane w czasie kompilacji nie równają się pełnej kompletności biznesowej.
Strategia wyszukiwania — bazy danych lokalne.
W fazie Bazy Danych Lokalnych Strategii Poszukiwania należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed modyfikacją kodu. Operatorzy powinni móc ponownie uruchomić ten krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Zapisuj czas trwania oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy ścieżka przechodzi z środowiska demonstracyjnego do współdzielonych środowisk. Wprowadź ludzką aprobatę dla operacji, które generują wydatki lub zmieniają dane produkcyjne. Podłączenia w czasie kompilacji nie równają się pełności funkcjonalności biznesowej. W fazie Bazy Danych Lokalnych Strategii Poszukiwania należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed modyfikacją kodu. Operatorzy powinni móc ponownie uruchomić ten krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Zdokumentuj zarówno ścieżkę prawidłowego działania, jak i ścieżkę naprawczą. Próby ponownych działań, ludzkie kontrolne punkty oraz obsługa wiadomości błędowych stanowią część produktu, a nie coś dodanego później.
Rozdział poświęcony językowi polskiemu.
Strategie wgrzania i oceny
Podczas przechodzenia przez etap strategii wgrzania i oceny najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Wolno preferować małe, testowalne jednostki zamiast rozbudowanych skryptów. Gdy jakiś krok się nie powiedzie, błąd powinien wskazywać na konkretną odpowiedzialność, a nie na skomplikowany proces. Zmierz stopień przywoływania informacji na ustalonej serii pytań przed dostosowywaniem promptów. Częste zmiany promptów rzadko naprawiają słabe mechanizmy wyszukiwania.
Strategie kontekstowe
Gdy przechodzisz przez etap Strategii Kontekstowych, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nadaj nazwy poszczególnym elementom, zdefiniuj kryteria sukcesu i odrzuć przypadki cichego, częściowego ukończenia zadania. Ustaw punkty kontrolne po kosztownych krokach. Narzędzie do kontynuacji pracy nie powinno ponownie naliczać opłat za tę samą próbę wywołania LLM, gdy operator ponawia działanie późniejszego węzła.
Optymalizacja promptu
Podczas prace nad etapem optymalizacji promptów najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Zapisz czasy wykonywania oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy przechodzi się z środowiska demonstracyjnego do współdzielonych środowisk. Zachowuj w pamięci tymczasowej stabilne instrukcje systemu oraz schematy narzędzi. Ponowne wysyłanie identycznego prefiksu to częsty powód marnotrawstwa zasobów. Podczas prace nad etapem optymalizacji promptów najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Zdokumentuj zarówno ścieżkę prawidłowego działania, jak i ścieżkę naprawczą. Próby ponownych wysiłków, mechanizmy ludzkiej kontroli oraz obsługa wiadomości błędnych stanowią część produktu, a nie elementy dodawane później.
Ćwiczenie 1: Załaduj pojedynczy model i przeprowadź prostą rozmowę.
Etap „Ładowanie 1” z ćwiczenia działa najlepiej, gdy traktuje się go jako mierzalną powierzchnię. Zapisz jeden idealny przypadek, jeden przypadek awarii oraz notatkę o cofnięciu działań, zanim rozszerzysz zakres pracy. Wolij małe, testowalne jednostki nad rozbudowane skrypty. Gdy jakiś krok zawiedzie, awaria powinna wskazywać na konkretną odpowiedzialność, a nie na skomplikowany łańcuch operacji. Określ budżet tokenów na jeden ruch i na jedną sesję. Narzędzia typu agentic intensywnie rozszerzają kontekst; sztywne limity zapobiegają temu, by demonstracje przerodziły się w niespodziewane rachunki.
# Install the library
pip install llmlight
from LLMlight import LLMlight
# Initialize the LLMlight client
client = LLMlight(model='google/gemma-4-26b-a4b-qat', endpoint="http://localhost:1234/v1/chat/completions")
# Ask a question
response = client.prompt('What is the capital of France?')
print(response)
# [LLMlight.LLM] [INFO ] Model : google/gemma-4-26b-a4b-qat
# [LLMlight.LLM] [INFO ] Context strategy : disabled
# [LLMlight.LLM] [INFO ] Retrieval method : naive_rag
# [LLMlight.LLM] [INFO ] Embedding : {'memory': 'bert', 'context': 'bert'}
# [LLMlight.LLM] [INFO ] Alpha (sig. test): None
# [LLMlight.LLM] [INFO ] Chunk config : {'method': 'chars', 'size': 1000, 'overlap': 200}
# [LLMlight.LLM] [INFO ] LLMlight initialised.
# [LLMlight.LLM] [INFO ] Creating response with google/gemma-4-26b-a4b-qat..
# [LLMlight.LLM] [INFO ] No context strategy applied.
# [LLMlight.LLM] [INFO ] No context is provided into the prompt.
# [LLMlight.LLM] [INFO ] Running model: google/gemma-4-26b-a4b-qat
# The capital of France is Paris.
Ćwiczenie 2: Stworz lokalną bazę wiedzy.
Ćwiczenie 2 „Stworzenie etapu” działa najlepiej, gdy traktuje się je jako mierzalną powierzchnię. Zapisz jeden idealny przypadek, jeden przypadek niepowodzenia oraz notatkę o cofnięciu działań, zanim rozszerzysz zakres pracy. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nadaj nazwy poszczególnym elementom, zdefiniuj kryteria sukcesu i odrzuć ciche, częściowe ukończenie zadań. Utrzymuj stan grafu w prostej formie i określ jego typ. Wложone struktury ukrywają informację o tym, który węzeł zapisał dane do którego pola, co powoduje przerwanie kontynuacji po interwencjach.
# Import library
from LLMlight import LLMlight
# Initialize model and memory
client = LLMlight(model='google/gemma-4-26b-a4b-qat', endpoint="http://localhost:1234/v1/chat/completions")
# Create (or load) database
client.memory_init(store_path='knowledge_base.db')
# Add a PDF file to the database (extracts and chunks text automatically)
url = 'https://proceedings.neurips.cc/paper_files/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf'
pdf_text = client.read_pdf(url)
# Write to db
client.memory_add(text=pdf_text)
# Show the chunks
client.memory_chunks(1)
# Store to disk (SQLite DB is persisted automatically)
client.memory_save()
# Query on the new knowledge
response = client.prompt(query='What are attention networks?', response_format='Summarize in 3 sentences.')
print(response)
Ćwiczenie 3: Różnice w wynikach przy użyciu metod strategii kontekstowej.
Etap Ćwiczenia 3 „Różnice” funkcjonuje najlepiej, gdy traktowany jest jako mierzalna powierzchnia do analizy. Zapisz jeden idealny przepis działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian, zanim rozszerzysz zakres pracy. Zapisuj czasy wykonywania operacji oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy ścieżka przechodzi z środowiska demonstracyjnego do współdzielonych środowisk. Utrzymuj stan grafu w prostej formie i z określonym typem danych. Wplecione elementy ukrywają informację o tym, który węzeł zapisał dane do którego pola, co powoduje przerwę w kontynuacji pracy po zakłóceniach. Etap Ćwiczenia 3 „Różnice” funkcjonuje najlepiej, gdy traktowany jest jako mierzalna powierzchnia do analizy. Zapisz jeden idealny przepis działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian, zanim rozszerzysz zakres pracy. Dokumentuj zarówno ścieżkę prawidłowego działania, jak i ścieżkę przywracania do stanu poprzedniego. Próby ponownych działań, kontrolne punkty ludzkie oraz obsługa wiadomości nieodebranych stanowią część produktu, a nie elementy dodawane później.
from LLMlight import LLMlight
# Initialize with NO context strategy
client = LLMlight(model='google/gemma-4-26b-a4b-qat', retrieval_method='naive_rag', context_strategy=None, top_chunks=6, endpoint="http://localhost:1234/v1/chat/completions")
# Create (or load) database
client.memory_init(store_path='knowledge_base.db')
# Query on the new knowledge
response = client.prompt(query='What are attention networks?', response_format='Summarize in 2 sentence')
print(response)
# Based on the provided text, attention networks utilize mechanisms like self-attention
# to perform tasks such as reading comprehension, summarization, and machine translation
# by capturing the syntactic and semantic structures of sentences.
# They operate by computing attention weights on "values" using "queries" and "keys" through
# a softmax function, with common types being additive or dot-product multiplicative attention.
from LLMlight import LLMlight
# Initialize with CHUNK-WISE context strategy
client = LLMlight(model='google/gemma-4-26b-a4b-qat', retrieval_method='naive_rag', context_strategy='chunk-wise', top_chunks=6, endpoint="http://localhost:1234/v1/chat/completions")
# Create (or load) database
client.memory_init(store_path='knowledge_base.db')
# Query on the new knowledge
response = client.prompt(query='What are attention networks?', response_format='Summarize in 2 sentence')
# [LLMlight.LLM] [INFO ] Chunk wise analysis on 6 chunks of text.
# Processing chunk: 0%| | 0/6 [00:00<?, ?chunk/s][08-06-2026 22:11:53] [LLMlight.LLM] [INFO ] Working on text chunk 1/6
# Processing chunk: 17%|█▋ | 1/6 [00:54<04:31, 54.24s/chunk][08-06-2026 22:12:47] [LLMlight.LLM] [INFO ] Working on text chunk 2/6
# Processing chunk: 33%|███▎ | 2/6 [01:18<02:26, 36.66s/chunk][08-06-2026 22:13:12] [LLMlight.LLM] [INFO ] Working on text chunk 3/6
# Processing chunk: 50%|█████ | 3/6 [01:30<01:15, 25.33s/chunk][08-06-2026 22:13:23] [LLMlight.LLM] [INFO ] Working on text chunk 4/6
# Processing chunk: 67%|██████▋ | 4/6 [01:51<00:47, 23.81s/chunk][08-06-2026 22:13:45] [LLMlight.LLM] [INFO ] Working on text chunk 5/6
# Processing chunk: 83%|████████▎ | 5/6 [02:47<00:35, 35.13s/chunk][08-06-2026 22:14:40] [LLMlight.LLM] [INFO ] Working on text chunk 6/6
# Processing chunk: 100%|██████████| 6/6 [03:14<00:00, 32.48s/chunk]
# [LLMlight.LLM] [INFO ] Running model: google/gemma-4-26b-a4b-qat
print(response)
# The provided context does not contain a formal definition of "attention networks."
# It only describes the mathematical mechanism of attention, which uses queries, keys, and values to
# compute output weights through methods like scaled dot-product or additive attention.
from LLMlight import LLMlight
# Initialize with GLOBAL-REASONING context strategy
client = LLMlight(model='google/gemma-4-26b-a4b-qat', retrieval_method='naive_rag', context_strategy='global-reasoning', top_chunks=6)
# Create (or load) database
client.memory_init(store_path='knowledge_base.db')
# Query on the new knowledge
response = client.prompt(query='What are attention networks?', response_format='Summarize in 2 sentence')
# [LLMlight.LLM] [INFO ] Global-reasoning on 6 chunks of text.
# Processing chunk: 100%|██████████| 6/6 [03:14<00:00, 32.48s/chunk]
# [LLMlight.LLM] [INFO ] Running model: google/gemma-4-26b-a4b-qat
print(response)
# Based on the provided text, attention networks are computational mechanisms that use queries, keys,
# and values to determine weights via a scaled dot-product and a softmax function.
# These networks can enhance model interpretability and, when combined with feed-forward layers, achieve a computational
# complexity similar to separable convolutions.
Ćwiczenie 4: Stworzenie dyskusji pomiędzy dwoma agentami na wybrany temat.
W ramach ćwiczenia 4 „Stworzenie scenariusza” należy najpierw zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić dany krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu systemu. Należy preferować małe, łatwe do przetestowania jednostki nad rozbudowanymi skryptami. Gdy jakiś krok zawiedzie, powinno to wskazywać na konkretną przyczynę, a nie na skomplikowaną strukturę procesów. Zatwierdzenie przez człowieka powinno być wymagane w przypadkach, gdy dochodzi do wydawania pieniędzy lub modyfikacji danych produkcyjnych. Połączenia realizowane w czasie kompilacji nie gwarantują pełnej kompletności rozwiązania biznesowego.
# Initialize
from LLMlight import LLMlight
# temperature=0.1 Lower means a More factual debate
# temperature=1.0 Higher means more creative discussion
# top_chunks=10 Use more retrieved context
# embedding='bert' Strong semantic retrieval
# retrieval_method='naive_rag' Standard RAG retrieval
# ====================================================
# Agent A: Data Scientist
# ====================================================
agent_a = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
embedding="bert",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
# Set the database for Agent 1
agent_a.memory_init(store_path="agent_a.db")
# Add some background information database for agent 1
agent_a.memory_add("""
Large Language Models are one of the most important step we did in the field of AI
It helps the workload and the work easier and faster.
""")
agent_a.memory_add("""
Large Language Models use transformer architectures and are trained on
massive text corpora using self-supervised learning.
""")
# ====================================================
# Agent B: Farmer
# ====================================================
agent_b = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
embedding="bert",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
# Set the database for Agent 2
agent_b.memory_init(store_path="agent_b.db")
# Add some background information database for agent 2
agent_b.memory_add("""
The use of AI and machine learning consumes to much power and there is no need for this
new technology. The human work was good enough and there is no need to change that.
""")
agent_b.memory_add("""
Recent research shows that LLMs hallucinate and do not solve real world applications.
""")
# ====================================================
# Discussion Loop
# ====================================================
topic = "Discuss the importance of the use of Large Language Models and AI."
message = topic
for turn in range(5):
print(f"\n{'='*80}")
print(f"ROUND {turn+1}")
print(f"{'='*80}")
response_a = agent_a.prompt(
system='You are a Data Scientist.',
query=
f"""
Topic:
{message}
""",
response_format='Give your opinion in 1-2 paragraphs and ask a question to the other agent.',
)
print("\nAgent A:")
print(response_a)
response_b = agent_b.prompt(
system='You are a farmer.',
f"""
The Data Scientist said:
{response_a}
""",
response_format='Respond to the discussion in 1-2 paragraphs and ask a follow-up question.',
)
print("\nAgent B:")
print(response_b)
message = response_b
Prezentacja trzeciego agenta: moderatora
W fazie wprowadzania trzeciego agenta należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić ten krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Traktuj tę fazę jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nazwij poszczególne elementy, zdefiniuj kryteria sukcesu i odrzuć ciche, częściowe ukończenie zadania. Konieczna jest ludzka akceptacja w przypadku operacji, które wiążą się z wydawaniem pieniędzy lub modyfikacją danych produkcyjnych. Połączenia realizowane w czasie kompilacji nie równają się pełnej kompletności biznesowej.
from LLMlight import LLMlight
# ====================================================
# Agent A: Data Scientist
# ====================================================
agent_a = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
agent_a.memory_init(store_path="agent_a.db")
agent_a.memory_add("""
Large Language Models are one of the most important step we did in the field of AI
It helps the workload and the work easier and faster.
Large Language Models use transformer architectures and are trained on
massive text corpora using self-supervised learning.
""")
# ====================================================
# Agent B: Farmer
# ====================================================
agent_b = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
agent_b.memory_init(store_path="agent_b.db")
agent_b.memory_add("""
The use of AI and machine learning consumes to much power and there is no need for this
new technology. The human work was good enough and there is no need to change that.
Recent research shows that LLMs hallucinate and do not solve real world applications.
""")
# ====================================================
# Agent C: Moderator
# ====================================================
moderator = LLMlight(
model="openai/gpt-oss-20b",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.3, # lower temperature for objective summaries
)
moderator.memory_init(store_path="moderator.db")
# ====================================================
# Shared discussion memory
# ====================================================
shared_memory = LLMlight(model="openai/gpt-oss-20b")
shared_memory.memory_init(store_path="discussion.db")
# ====================================================
# Discussion Loop
# ====================================================
topic = "Discuss the importance of the use of Large Language Models and AI."
message = topic
for turn in range(5):
print(f"\n{'='*80}")
print(f"ROUND {turn+1}")
print(f"{'='*80}")
# --------------------------------------------
# Agent A responds
# --------------------------------------------
response_a = agent_a.prompt(
system='You are a Data Scientist.',
query=
f"""
Current discussion:
{message}
""",
instructions='Provide your opinion and ask a question to the Farmer.',
response_format='Response can be maximum 1-2 paragraphs.'
)
print("\nData Scientist:")
print(response_a)
# --------------------------------------------
# Agent B responds
# --------------------------------------------
response_b = agent_b.prompt(
system='You are a Farmer.',
query=f"""
The Data Scientist said:
{response_a}
"""
instructions='Respond and ask a follow-up question.',
response_format='Response can be maximum 1-2 paragraphs.'
)
print("\nFarmer:")
print(response_b)
# --------------------------------------------
# Moderator summarizes
# --------------------------------------------
moderator_summary = moderator.prompt(
system='You are a neutral moderator.',
query=
f"""
Data Scientist:
{response_a}
Farmer:
{response_b}
Perform the following tasks:
1. Summarize the key arguments.
2. Identify agreements.
3. Identify disagreements.
4. Propose one question that helps both agents move toward consensus.
""",
response_format='Keep the output concise.'
)
print("\nModerator:")
print(moderator_summary)
# Store discussion history
shared_memory.memory_add(response_a)
shared_memory.memory_add(response_b)
shared_memory.memory_add(moderator_summary)
# Next round starts from moderator guidance
message = moderator_summary
# ====================================================
# Final consensus
# ====================================================
consensus = moderator.prompt(
system='You are a neutral moderator.',
query=
"""
Review the discussion and provide:
- Main conclusions
- Remaining disagreements
- Final consensus statement
""",
response_format='Keep it under 200 words.'
)
print("\nFINAL CONSENSUS")
print("=" * 80)
print(consensus)
Kontrolowanie rozmowy za pomocą agenta oceniającego.
W etapie Kontroli rozmowy należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić ten krok od znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Zapisuj czas trwania oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy ścieżka przechodzi z środowiska demonstracyjnego do współdzielonych środowisk. Wprowadź ludzką aprobatę dla operacji, które generują wydatki lub zmieniają dane produkcyjne. Połączenia skompilowane w czasie kompilacji nie równają się pełności funkcjonalności biznesowej. W etapie Kontroli rozmowy należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed zmianą kodu. Operatorzy powinni móc ponownie uruchomić ten krok od znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Zdokumentuj zarówno ścieżkę pomyślną, jak i ścieżkę naprawczą. Próby ponownych działań, ludzkie kontrolne punkty oraz obsługa wiadomości błędnych stanowią część produktu, a nie
późniejsza polszczyzna.from LLMlight import LLMlight
# ====================================================
# Agent A: Data Scientist
# ====================================================
agent_a = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
agent_a.memory_init(store_path="agent_a.db", overwrite=True)
# ====================================================
# Agent B: Farmer
# ====================================================
agent_b = LLMlight(
model="google/gemma-4-26b-a4b-qat",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.7,
)
agent_b.memory_init(store_path="agent_b.db", overwrite=True)
# ====================================================
# Moderator Agent (keeps discussion structured)
# ====================================================
moderator = LLMlight(
model="openai/gpt-oss-20b",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.3,
)
moderator.memory_init(store_path="moderator.db", overwrite=True)
# ====================================================
# Scoring Agent (decides convergence / stopping)
# ====================================================
scoring_agent = LLMlight(
model="liquid/lfm2-24b-a2b",
retrieval_method="naive_rag",
context_strategy=None,
top_chunks=5,
temperature=0.0, # deterministic scoring
)
scoring_agent.memory_init(store_path="scoring.db", overwrite=True)
# ====================================================
# Shared memory (optional logging)
# ====================================================
shared_memory = LLMlight(model="liquid/lfm2-24b-a2b")
shared_memory.memory_init(store_path="discussion.db", overwrite=True)
# ====================================================
# Discussion Loop with early stopping
# ====================================================
topic = "Discuss the importance of attention mechanisms in modern AI."
message = topic
MAX_ROUNDS = 5
AGREEMENT_THRESHOLD = 0.85 # stop if convergence is high enough
for turn in range(MAX_ROUNDS):
print(f"\n{'='*80}")
print(f"ROUND {turn+1}")
print(f"{'='*80}")
# --------------------------
# Agent A
# --------------------------
response_a = agent_a.prompt(
system='You are a Data Scientist.',
query=f"""
Topic:
{message}
""",
instructions='Ask a question.',
response_format='Respond in 1-2 paragraphs',
)
print("\nAgent A:")
print(response_a)
# --------------------------
# Agent B
# --------------------------
response_b = agent_b.prompt(
system='You are a Farmer.',
query=
f"""
Data Scientist said:
{response_a}
""",
instructions='continue the discussion with your own opinion.',
response_format='Respond in 1-2 paragraphs.',
)
print("\nAgent B:")
print(response_b)
# --------------------------
# Moderator summary
# --------------------------
moderator_summary = moderator.prompt(
system='You are a neutral moderator.',
query=f"""
Data Scientist:
{response_a}
Farmer:
{response_b}
""",
instructions=
"""
Summarize:
- agreements
- disagreements
- next question toward consensus
"""
)
print("\nModerator:")
print(moderator_summary)
# --------------------------
# Scoring Agent (convergence check)
# --------------------------
score_output = scoring_agent.prompt(
system='You are a scoring system.',
query=f"""
Data Scientist:
{response_a}
Farmer:
{response_b}
Moderator summary:
{moderator_summary}
""",
instructions='Evaluate agreement between the two agents.',
response_format=
"""
Return ONLY a number between 0 and 1:
- 1.0 = full agreement / consensus reached
- 0.0 = complete disagreement
""",
)
try:
score = float(score_output.strip())
except:
score = 0.0
print("\nAgreement Score:", score)
# --------------------------
# Store memory
# --------------------------
shared_memory.memory_add(response_a)
shared_memory.memory_add(response_b)
shared_memory.memory_add(moderator_summary)
# --------------------------
# Early stopping condition
# --------------------------
if score >= AGREEMENT_THRESHOLD:
print("\nConsensus reached early. Stopping discussion.")
break
# Next round context
message = moderator_summary
# ====================================================
# Final summary
# ====================================================
final_summary = shared_memory.prompt("""
Summarize the full discussion:
- final consensus
- key arguments
- remaining open points (if any)
""")
print("\nFINAL SUMMARY")
print("=" * 80)
print(final_summary)
# ========================
# ROUND 1
# ========================
# Agreement Score: 0.3
# ========================
# ROUND 2
# ========================
# Agreement Score: 0.7
# ========================
# ROUND 3
# ========================
# Agreement Score: 0.6
# ========================
# ROUND 4
# ========================
# Agreement Score: 0.8
# ========================
# ...
Dobre instrukcje są kluczowe.
Gdy przechodzisz przez etap „Dobre instrukcje są kluczowe”, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co się dzieje w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Wolno preferować małe, testowalne jednostki zamiast rozbudowanych skryptów. Gdy jakiś krok się nie powiedzie, błąd powinien wskazywać na konkretną odpowiedzialność, a nie na skomplikowany proces. Zrób kontrolę po kosztownych krokach. System powinien unikać ponownego pobierania opłat za tę samą funkcję LLM, gdy operator próbuje ponownie uruchomić późniejszy węzeł.
response = client.prompt(
query="Explain attention mechanisms.",
instructions="""
Explain the concept for beginners.
Use exactly three paragraphs.
Include one real-world example.
""",
system="You are an experienced AI professor.",
context="some context", # This is autofilled too based on the database and RAG model.
response_format="markdown"
)
Główne wnioski przed tworzeniem modeli językowych
Gdy przechodzisz przez etap „Wnioski przed stworzeniem języka”, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nadaj nazwy poszczególnym elementom, zdefiniuj kryteria sukcesu i odrzuć możliwość cichego, częściowego ukończenia zadania. Zachowuj w pamięci tymczasowej stabilne instrukcje systemu oraz schematy narzędzi. Ponowne wysyłanie identycznego nagłówka jest częstą przyczyną marnotrawstwa zasobów.
Podsumowanie: Nie szukaj szybkości, szukaj struktury
Gdy przechodzisz przez etap „Wrapping Up Don’t”, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Zapisz czasy wykonywania oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy ścieżka przechodzi z wersji demonstracyjnej do środowisk współdzielonych. Ustal punkty kontrolne po kosztownych krokach. Narzędzie do kontynuacji pracy nie powinno ponownie naliczać opłat za tę samą wywołanie LLM, gdy operator próbuje ponownie uruchomić późniejszy węzeł. Gdy przechodzisz przez etap „Wrapping Up Don’t”, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Zdokumentuj zarówno ścieżkę prawidłowego działania, jak i ścieżkę naprawczą. Próby ponownych wywołań, mechanizmy ludzkiej kontroli oraz obsługa wiadomości błędowych są częścią produktu, a nie elementem dodatkowej optymalizacji.
Oprogramowanie
Etap oprogramowania funkcjonuje najlepiej, gdy traktowany jest jako mierzalna powierzchnia. Zapisz jeden idealny zapis działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian, zanim rozszerzysz zakres pracy. Wolij małe, testowalne jednostki nad rozbudowane skrypty. Gdy jakiś krok się nie powiedzie, awaria powinna wskazywać na konkretną odpowiedzialność, a nie na skomplikowany łańcuch operacji. Utrzymuj stan grafu w formie prostych, typowanych struktur. Wplecione bloki danych ukrywają informację o tym, który węzeł zapisał dane do którego pola, co utrudnia kontynuację pracy po przerwach.
Odnośniki
Etap odnośników funkcjonuje najlepiej, gdy traktowany jest jako mierzalna powierzchnia. Zapisz jeden idealny zapis działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian, zanim rozszerzysz zakres pracy. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi danymi wyjściowymi. Nadaj nazwy poszczególnym elementom, zdefiniuj kryteria sukcesu i odrzucaj ciche, częściowe ukończenie zadań. Utrzymuj stan grafu w formie prostych, typowanych struktur. Wplecione bloki danych ukrywają informację o tym, który węzeł zapisał dane do którego pola, co utrudnia kontynuację pracy po przerwach.
List kontrolny operacyjny
Etap listy kontrolnej operacyjnej działa najlepiej, gdy traktuje się go jako mierzalną powierzchnię. Zapisz jeden idealny przepis działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian, zanim rozszerzysz zakres.
Zachowaj konfigurację poza kodem aplikacji. Pliki środowiskowe, magazyny tajnych danych oraz flagi funkcjonalne powinny znajdować się w jednym miejscu, które operatorzy mogą sprawdzić bez konieczności przeglądania całej struktury.
Zachowaj stan struktury w formie prostej i typizowanej. Wkładki nawiasowe ukrywają informację o tym, który węzeł zapisał dane w danym polu, co utrudnia kontynuację pracy po przerwach.
Gdy budżet na to pozwala, dodaj test sprawdzający kluczową ścieżkę działania w procesie CI przy użyciu narzędzi testowych, a nie rzeczywistych, płatnych API.
Zdokumentuj zarówno prawidłową ścieżkę działania, jak i ścieżkę odzyskiwania. Próby ponownych działań, procedury ludzkie oraz obsługa wiadomości błędowych stanowią część produktu, a nie elementy dodawane później.
Zachowaj prostą i typowaną strukturę stanu grafu. Wkładane błotka ukrywają informację o tym, który węzeł zapisał dane do którego pola, i powodują przerwanie pracy po przerwach.
Zanim zastosujesz stos, zamroź wersje, utwórz „złoty zapis” dla kluczowej ścieżki oraz potwierdź kroki odwracania zmian. Środowiska współdzielone wymagają ograniczeń szybkości, weryfikacji użytkowników oraz wyraźnego właściciela odpowiedzialnego za rotację haseł. Wolisz nudną niezawodność niż sprytnie przygotowane jednorazowe demonstracje.
Uwaga dotycząca 24c6cd6fa849: trzymaj klucze dostawcy poza repozytorium, ustaw ograniczenie liczby tokenów na sesję oraz przechowuj zapisy obok narzędzi do oceny, aby późniejsze zamiany modeli pozostały porównywalne.
Notatka dotycząca wzmocnienia bezpieczeństwa na etapie 0 działa najlepiej, gdy traktuje się ją jako mierzalną powierzchnię do analizy. Zapisz jeden idealny przypadek działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian przed rozszerzeniem zakresu prac. Zapisz czasy wykonywania operacji oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy proces przechodzi z środowiska demonstracyjnego do współdzielonych środowisk.
Szczegóły wzmocnienia bezpieczeństwa 0/872: zmierz czas wykonywania operacji, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę na podstawie ustalonego zestawu pytań, a nie jedynie informacji anegdotycznych.
Dla etapu 1 notatki dotyczącej wzmocnienia bezpieczeństwa zdefiniuj dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed modyfikacją kodu. Operatorzy powinni móc ponownie wykonać ten krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu systemu. Zdokumentuj zarówno prawidłowy przebieg procesu, jak i ścieżkę naprawczą. Próby ponownych działań, mechanizmy kontroli ludzkiej oraz obsługa wiadomości błędnych stanowią część produktu, a nie elementy dodawane później.
Szczegół wzmocnienia 1/872: zmierz czas wykonywania, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę na podstawie ustalonego zestawu pytań, a nie jedynie anegdoty.
Podczas przechodzenia przez drugi etap notatki dotyczącej wzmocnienia, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego niepowodzenia. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nadaj nazwy poszczególnym elementom, zdefiniuj kryteria sukcesu i odrzuć ciche, częściowe ukończenie zadania.
Szczegół wzmocnienia 2/872: zmierz czas wykonywania, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę na podstawie ustalonego zestawu pytań, a nie jedynie anegdoty.
Metoda zaostrzania bezpieczeństwa na etapie 3 działa najlepiej, gdy traktuje się ją jako mierzalną powierzchnię do analizy. Zapisz jeden idealny przykład działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian, zanim rozszerzysz zakres prac. Przechowuj konfigurację poza kodem aplikacji. Pliki środowiskowe, magazyny haseł oraz flagi funkcjonalne powinny znajdować się w jednym miejscu, które operatorzy mogą sprawdzić bez konieczności analizy całej struktury.
Szczegół zaostrzania bezpieczeństwa 3/872: zmierz czas wykonywania operacji, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę, opierając się na ustalonej serii pytań, a nie na indywidualnych obserwacjach.
Dla etapu 4 notatki dotyczącej wzmocnienia bezpieczeństwa należy zdefiniować dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed modyfikacją kodu. Operatorzy powinni móc ponownie uruchomić dany krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Należy preferować małe, testowalne jednostki zamiast rozbudowanych skryptów. Gdy dany krok zawiedzie, powód awarii powinien wskazywać na konkretną odpowiedzialność, a nie na skomplikowany proces.
Szczegół 4/872 dotyczący wzmocnienia bezpieczeństwa: zmierz czas wykonywania, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę, opierając się na ustalonej serii pytań, a nie na indywidualnych obserwacjach.
Gdy przechodzisz przez etap nr 5 notatki dotyczącej wzmocnienia bezpieczeństwa, najpierw zapisz warunki kontraktu: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego awarii. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Obok wyników funkcjonalnych zapisz czas wykonywania oraz koszt tokena lub zapytania. Jasna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy ścieżka przechodzi z środowiska demonstracyjnego do współdzielonych środowisk.
Szczegóły wzmocnienia bezpieczeństwa 5/872: zmierz czas wykonywania, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę na podstawie ustalonego zestawu pytań, a nie jedynie osobistych obserwacji.
Etap nr 6 notatki dotyczącej wzmocnienia bezpieczeństwa działa najlepiej, gdy traktuje się go jako mierzalną powierzchnię do analizy. Zanim rozszerzysz zakres, zapisz jeden idealny przepływ działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian. Zdokumentuj razem ścieżkę prawidłowego działania oraz ścieżkę naprawczą. Próby ponownych działań, kontrolne punkty ludzkie oraz obsługa wiadomości błędnych stanowią część produktu, a nie elementy dodawane później.
Szczegóły wzmocnienia 6/872: zmierz czas wykonywania, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę na podstawie ustalonego zestawu pytań, a nie jedynie anegdoty.
W etapie 7 notatki dotyczącej wzmocnienia określ dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed modyfikacją kodu. Operatorzy powinni móc ponownie wykonać ten krok na podstawie znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nadaj nazwy artefaktom, zdefiniuj sprawdzenia sukcesu i odrzuć ciche, częściowe ukończenie zadania.
Szczegóły wzmocnienia 7/872: zmierz czas wykonywania, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę na podstawie ustalonego zestawu pytań, a nie jedynie anegdoty.
Gdy przechodzisz przez etap nr 8 notatki dotyczącej wzmocnienia bezpieczeństwa, najpierw zapisz warunki kontraktu: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego awarii. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Przechowuj konfigurację poza kodem aplikacji. Pliki środowiskowe, magazyny tajnych danych oraz flagi funkcjonalne powinny znajdować się w jednym miejscu, które operatorzy mogą sprawdzić bez konieczności czytania całej struktury.
Szczegół nr 8/872 dotyczący wzmocnienia bezpieczeństwa: zmierz czas wykonywania, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę na podstawie ustalonego zestawu pytań, a nie jedynie informacji anegdotycznych.
Etap nr 9 notatki dotyczącej wzmocnienia bezpieczeństwa działa najlepiej, gdy traktuje się go jako mierzalną powierzchnię do analizy. Zapisz jeden idealny przykład działania, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian, zanim rozszerzysz zakres prac. Wolij małe, testowalne jednostki nad rozbudowane skrypty. Gdy jakiś krok zawiedzie, awaria powinna wskazywać na konkretną odpowiedzialność, a nie na skomplikowaną sekwencję działań.
Szczegóły wzmocnienia bezpieczeństwa 9/872: zmierz czas wykonywania, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę na podstawie ustalonego zestawu pytań, a nie jedynie anegdoty.
W etapie 10 notatki dotyczącej wzmocnienia bezpieczeństwa zdefiniuj dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed modyfikacją kodu. Operatorzy powinni móc ponownie wykonać ten krok od znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Zapisuj czas wykonywania oraz koszt tokenów lub zapytań obok wyników funkcjonalnych. Wczesna widoczność kosztów zapobiega niespodziewanym rachunkom, gdy ścieżka przechodzi z środowiska demonstracyjnego do współdzielonych środowisk.
Szczegóły wzmocnienia bezpieczeństwa 10/872: zmierz czas wykonywania, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę na podstawie ustalonego zestawu pytań, a nie jedynie anegdoty.
Gdy przechodzisz przez etap 11 notatki dotyczącej wzmocnienia bezpieczeństwa, najpierw zapisz umowę: wymagane dane wejściowe, sygnał sukcesu oraz to, co dzieje się w przypadku częściowego awarii. Taka lista kontrolna zapewnia uczciwość późniejszych zmian w kodzie. Zdokumentuj zarówno ścieżkę prawidłowego działania, jak i ścieżkę przywracania stanu. Próby ponownych działań, kontrola przez ludzi oraz obsługa wiadomości błędowych stanowią część produktu, a nie elementy dodawane później.
Szczegół 11/872 dotyczący wzmocnienia bezpieczeństwa: zmierz czas wykonywania operacji, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę na podstawie ustalonego zestawu pytań, a nie jedynie informacji anegdotycznych.
Etap 12 notatki dotyczącej wzmocnienia bezpieczeństwa działa najlepiej, gdy traktuje się go jako mierzalną powierzchnię do poprawek. Zapisz jeden idealny przepływ operacji, jeden przypadek awarii oraz notatkę dotyczącą cofnięcia zmian, zanim rozszerzysz zakres prac. Traktuj ten etap jako umowę pomiędzy danymi wejściowymi a zweryfikowanymi wynikami. Nadaj nazwy poszczególnym elementom, zdefiniuj kryteria sukcesu i odrzuć przypadki cichego, częściowego ukończenia zadania.
Szczegóły wzmocnienia 12/872: zmierz czas wykonywania, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę na podstawie ustalonego zestawu pytań, a nie jedynie anegdoty.
W etapie 13 notatki dotyczącej wzmocnienia określ dane wejściowe, osobę odpowiedzialną za dany krok oraz kryteria zakończenia przed modyfikacją kodu. Operatorzy powinni móc ponownie uruchomić ten krok od znanego punktu kontrolnego, bez konieczności zgadywania ukrytego stanu. Konfigurację należy przechowywać poza kodem aplikacji. Pliki środowiskowe, magazyny tajnych danych oraz flagi funkcjonalne powinny znajdować się w jednym miejscu, które operatorzy mogą sprawdzić bez konieczności przeglądania całej struktury.
Szczegóły wzmocnienia 13/872: zmierz czas wykonywania, klasę błędu oraz zużycie tokenów dla tej notatki, a następnie zdecyduj, czy zachować zmianę na podstawie ustalonego zestawu pytań, a nie jedynie anegdoty.
Literatura pokrewna
- Praktyczne notatki: Agentic AI — Pozwól Ollamie napisać i zaprowadzić twój Python lokalnie — Szczegółowy przewodnik po Praktycznych notatkach: Agentic AI — Pozwól Ollamie napisać i zaprowadzić twój Python lokalnie: kontrakty, sprawdzenia oraz miejsca na kod do wstawienia dla zespołów wdrażających ten wzorzec.
- Praktyczne notatki: Budowanie aplikacji Agentic AI z lokalnym LLM — Bez chmury, bez API — Szczegółowy przewodnik po Praktycznych notatkach: Budowanie aplikacji Agentic AI z lokalnym LLM — Bez chmury, bez API: kontrakty, sprawdzenia oraz miejsca na kod do wstawienia dla zespołów wdrażających ten wzorzec.