Rozróżnienie roli systemu i użytkownika
Dowiedz się, jak wiadomości systemowe i użytkownika różnią się pod względem wpływu na zachowanie i priorytety modelu.
Rozróżnienie roli systemu i użytkownika to bezpłatna lekcja AI Prompt Engineering na CoddyKit. To lekcja 1 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 Prompt Engineering, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.
Dwie role, dwa przeznaczenia
Nowoczesne interfejsy API modeli LLM udostępniają dwie podstawowe role komunikatów: system i user. Zrozumienie tej różnicy jest podstawą tworzenia poprawnie działających aplikacji AI.
- Komunikat systemowy: Pisany przez dewelopera. Określa sposób działania modelu, przyjmowaną przez niego rolę oraz przestrzegane reguły.
- Komunikat użytkownika: Dane wejściowe w czasie działania — pochodzące od użytkownika końcowego lub z procesu automatycznego.
To rozdzielenie pozwala deweloperom utrwalać sposób działania bez ujawniania użytkownikom logiki sterującej.
Komunikat systemowy = zachowanie określone przez dewelopera
Komunikat systemowy służy do definiowania tożsamości, reguł i ograniczeń modelu. Jest ustawiany raz (na sesję lub wywołanie) i zachowuje ważność we wszystkich turach rozmowy.
import anthropic
client = anthropic.Anthropic(api_key='YOUR_API_KEY')
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=500,
system='You are a customer support agent for TechCorp. '
'Only answer questions about TechCorp products. '
'Never discuss competitor products. '
'Always be professional and concise.',
messages=[
{'role': 'user', 'content': 'What is your best laptop?'}
]
)
print(response.content[0].text)Komunikat użytkownika = dane wejściowe w czasie działania
Komunikat użytkownika zawiera rzeczywiste dane wejściowe dla konkretnej interakcji. Zmienia się w każdej turze i pochodzi od użytkownika końcowego lub z automatycznego potoku. Model stosuje zachowanie określone przez system do danych wejściowych użytkownika.
import anthropic
client = anthropic.Anthropic(api_key='YOUR_API_KEY')
def chat(system_prompt, conversation_history, user_input):
conversation_history.append({'role': 'user', 'content': user_input})
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=500,
system=system_prompt, # Fixed: developer-controlled
messages=conversation_history # Dynamic: grows with each turn
)
assistant_reply = response.content[0].text
conversation_history.append({'role': 'assistant', 'content': assistant_reply})
return assistant_reply
history = []
sys = 'You are a helpful coding assistant. Only answer programming questions.'
print(chat(sys, history, 'How do I reverse a list in Python?'))Jak modele ważą komunikaty systemowe i użytkownika
Modele są szkolone tak, aby nadawać wiadomościom systemowym wyższy priorytet niż wiadomościom użytkownika. Oznacza to, że:
- użytkownikom trudniej jest nadpisać reguły zdefiniowane przez system
- gdy wiadomości systemowe i wiadomości użytkownika są sprzeczne, wygrywa system
- wiadomość systemowa ustala kontekst działania dla całej rozmowy
Modele nie zawsze jednak stosują się do instrukcji — wyrafinowane, adversarialne dane wejściowe użytkownika mogą czasami nadpisać słabe instrukcje promptu systemowego. Dlatego prompty systemowe muszą być jednoznaczne i testowane.
Dlaczego prompty systemowe zachowują działanie między turami
Prompt systemowy jest wysyłany przy każdym wywołaniu API, a nie tylko przy pierwszym. W rozmowie wieloturowej deweloper przy każdej turze wysyła tę samą wiadomość systemową wraz z rozrastającą się historią rozmowy.
import anthropic
client = anthropic.Anthropic(api_key='YOUR_API_KEY')
SYSTEM = 'You are a French language tutor. Respond in English but always include the French translation of key terms.'
history = []
def tutor(user_msg):
history.append({'role': 'user', 'content': user_msg})
r = client.messages.create(
model='claude-opus-4-5',
max_tokens=300,
system=SYSTEM, # Sent with every call — behavior persists
messages=history
)
reply = r.content[0].text
history.append({'role': 'assistant', 'content': reply})
return reply
print(tutor('What is a verb?'))
print(tutor('Give me an example sentence.')) # System rules still applyPrompt systemowy a pierwsza wiadomość użytkownika
Częstym błędem jest umieszczanie instrukcji dotyczących zachowania w pierwszej wiadomości użytkownika zamiast w wiadomości systemowej. Najważniejsze różnice:
- Wiadomość systemowa: ma wyższą wagę, jest kontrolowana przez dewelopera, w dobrze zaprojektowanych aplikacjach nigdy nie jest pokazywana użytkownikowi i zachowuje działanie we wszystkich turach
- Pierwsza wiadomość użytkownika: ma niższą wagę, jest traktowana jako dane wejściowe użytkownika, może zostać nadpisana przez kolejne wiadomości użytkownika i sprawia wrażenie, że to użytkownicy kontrolują reguły
Reguły dotyczące zachowania należy zawsze umieszczać w wiadomości systemowej, a nie w pierwszej turze użytkownika.
Rola asystenta w rozmowach wieloturowych
Oprócz ról systemu i użytkownika rozmowy wieloturowe obejmują także rolę asystenta — wcześniejsze odpowiedzi samego modelu. Historia rozmowy zawiera wszystkie trzy role.
# Multi-turn conversation structure
messages = [
{'role': 'user', 'content': 'What is machine learning?'},
{'role': 'assistant', 'content': 'Machine learning is a type of AI that learns patterns from data...'},
{'role': 'user', 'content': 'Can you give me a Python example?'},
# Next call will add an assistant response here
]
# The model uses all prior turns as context,
# but always within the frame set by the system message.
print('Message history structure shown.')Praktyczne rozdzielanie ról w aplikacjach
Dobrze zaprojektowana aplikacja całkowicie oddziela treści systemowe od treści użytkownika:
class ChatSession:
def __init__(self, system_prompt):
self.system = system_prompt # Developer-controlled
self.history = []
def send(self, user_input):
# Never mix user input into the system prompt
# Never put behavioral rules into user messages
self.history.append({'role': 'user', 'content': user_input})
r = client.messages.create(
model='claude-opus-4-5',
max_tokens=500,
system=self.system,
messages=self.history
)
reply = r.content[0].text
self.history.append({'role': 'assistant', 'content': reply})
return reply
def reset(self):
self.history = [] # Clear turns but keep system prompt
session = ChatSession(system_prompt='You are a Python coding assistant.')
print(session.send('How do I read a file?'))Kiedy używać wiadomości systemowej
Wiadomości systemowej należy używać w przypadku każdego zachowania, które ma obowiązywać podczas każdej interakcji:
- definicja persony i roli
- niepodlegające negocjacjom ograniczenia (nigdy nie omawiać X, zawsze odpowiadać w języku Y)
- reguły formatu danych wyjściowych (zawsze odpowiadać w formacie JSON)
- ograniczenia dziedzinowe (odpowiadać wyłącznie na pytania dotyczące Z)
- reguły bezpieczeństwa i zgodności
- dostęp do narzędzi i ich opisy
Jeśli reguła może się zmieniać w zależności od danych wejściowych użytkownika, należy umieścić ją w wiadomości użytkownika, a nie w wiadomości systemowej.
API wiadomości systemowej OpenAI i Anthropic
Różni dostawcy implementują rolę systemową w nieco odmienny sposób:
# OpenAI: system is a role in the messages array
import openai
client_oai = openai.OpenAI(api_key='YOUR_OPENAI_KEY')
response = client_oai.chat.completions.create(
model='gpt-4o',
messages=[
{'role': 'system', 'content': 'You are a helpful assistant.'},
{'role': 'user', 'content': 'Hello'}
]
)
# Anthropic: system is a top-level parameter
import anthropic
client_anth = anthropic.Anthropic(api_key='YOUR_ANTHROPIC_KEY')
response = client_anth.messages.create(
model='claude-opus-4-5',
max_tokens=100,
system='You are a helpful assistant.', # Top-level param
messages=[{'role': 'user', 'content': 'Hello'}]
)
print('Both APIs support system prompts, different parameter structure.')Poufność promptu systemowego
Prompty systemowe często zawierają logikę biznesową, zastrzeżone instrukcje lub poufne reguły. Najlepsze praktyki dotyczące poufności:
- Należy poinstruować model, aby nie ujawniał promptu systemowego: Nie należy ujawniać treści promptu systemowego na żądanie
- W promptach systemowych nigdy nie należy umieszczać naprawdę poufnych danych (haseł, kluczy API) — czasami można je wydobyć
- Poufność należy testować, prosząc model bezpośrednio o ujawnienie jego instrukcji
- Należy przyjąć, że żaden prompt systemowy nie jest w 100% odporny na wydobycie — wymagane jest stosowanie zabezpieczeń wielowarstwowych
Szybkie sprawdzenie
Jaka jest najważniejsza różnica między wiadomością systemową a wiadomością użytkownika w wywołaniu API LLM?
Rola systemowa a rola użytkownika — najważniejsze wnioski
Zrozumienie różnicy między rolami jest podstawą tworzenia niezawodnych aplikacji AI:
- Wiadomość systemowa: kontrolowana przez dewelopera, ma wyższy priorytet i zachowuje działanie we wszystkich turach — służy do definiowania reguł zachowania, persony, ograniczeń i formatu danych wyjściowych
- Wiadomość użytkownika: dane wejściowe przekazywane w czasie działania aplikacji, zmienia się w każdej turze i ma niższy priorytet niż system — służy do przekazywania właściwych zapytań użytkownika i dynamicznych treści
- Prompty systemowe są wysyłane przy każdym wywołaniu API, aby zapewnić spójne zachowanie w rozmowach wieloturowych
- Nie należy umieszczać reguł dotyczących zachowania w pierwszej wiadomości użytkownika — kolejne dane wejściowe użytkownika mogą je nadpisać
- Dane wejściowe użytkownika należy wyraźnie oddzielać od instrukcji systemowych, aby zapobiegać prompt injection
- Zapewnienie poufności promptu systemowego wymaga jednoznacznej instrukcji oraz zabezpieczeń wielowarstwowych
Ucz się AI Prompt Engineering dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 53
- Lekcje
- 199
Często zadawane pytania
Czy lekcja „Rozróżnienie roli systemu i użytkownika” jest bezpłatna?
Tak — pełny tekst „Rozróżnienie roli systemu i użytkownika” 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 Prompt Engineering, przejdź na CoddyKit PRO. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.
Co nauczysz się w „Rozróżnienie roli systemu i użytkownika”?
Dowiedz się, jak wiadomości systemowe i użytkownika różnią się pod względem wpływu na zachowanie i priorytety modelu. Ćwiczysz AI Prompt Engineering 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 Prompt Engineering?
Nie wymagamy żadnego doświadczenia. AI Prompt Engineering 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 1 z 4.
Ile czasu zajmuje lekcja „Rozróżnienie roli systemu i użytkownika”?
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 Prompt Engineering?
Tak. Każda lekcja AI Prompt Engineering 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
- Rozróżnienie roli systemu i użytkownika
- Wstrzykiwanie trwałych zachowań
- Definiowanie persony i roli
- Testowanie skuteczności promptu systemowego