Forstå chatgrensesnittet
Slik fungerer chatgrensesnitt for LLM-er: roller, turer og øktkontekst.
Forstå chatgrensesnittet er en gratis leksjon i AI-prompt engineering på CoddyKit. Dette er leksjon 1 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AI-prompt engineering, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AI-prompt engineering inneholder totalt 4 leksjoner.
De tre rollene
Hver samtale med en LLM bygger på tre roller: system, user og assistant.
Rollen system angir reglene og personaen før samtalen starter. Rollen user brukes når du sender meldinger. Rollen assistant brukes av modellen når den svarer.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
message = client.messages.create(
model='claude-opus-4-5',
max_tokens=256,
system='You are a helpful cooking assistant.',
messages=[
{'role': 'user', 'content': 'What is mise en place?'}
]
)
print(message.content[0].text)Systemmeldingen
Systemmeldingen er modellens instruksjonshåndbok. Den behandles før den første turen fra user og forblir aktiv gjennom hele økten.
Bruk den til å angi persona, tone, domenebegrensninger eller utdataformat. Modellen bruker den som styrende kontekst gjennom hele samtalen.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
response = client.chat.completions.create(
model='gpt-4o',
messages=[
{
'role': 'system',
'content': 'You are a senior Python engineer. '
'Always include type hints and docstrings in your examples.'
},
{
'role': 'user',
'content': 'Show me a function that parses JSON safely.'
}
]
)
print(response.choices[0].message.content)Turer og samtaleflyt
En samtale er en sekvens av turer. Hver tur veksler: brukeren snakker, assistenten svarer, og brukeren snakker igjen.
Modellen ser hele historikken over turene ved hver forespørsel. Det er det som får samtalen til å føles som en sammenhengende dialog – men teknisk sett er hvert API-kall tilstandsløst og mottar hele konteksten hver gang.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
# Each call sends the FULL conversation history
history = [
{'role': 'system', 'content': 'You are a geography tutor.'},
{'role': 'user', 'content': 'What is the capital of France?'},
{'role': 'assistant', 'content': 'The capital of France is Paris.'},
{'role': 'user', 'content': 'And its population?'} # follow-up turn
]
response = client.chat.completions.create(
model='gpt-4o',
messages=history
)
print(response.choices[0].message.content)Sesjonskontekst
Sesjonskontekst er det løpende minnet i samtalen din. Hver bruker- og assistentmelding samles i history-arrayet.
Modellen har ikke noe separat minnelager – den trekker slutninger utelukkende fra det den ser i det gjeldende kontekstvinduet. Hvis du starter en ny økt, har modellen ikke noe minne om tidligere økter med mindre du legger inn denne informasjonen på nytt.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
# Simulating 3-turn session context
conversation = [
{'role': 'user', 'content': 'My name is Alex.'},
{'role': 'assistant', 'content': 'Nice to meet you, Alex!'},
{'role': 'user', 'content': 'What is 5 times 7?'},
{'role': 'assistant', 'content': '5 times 7 is 35.'},
{'role': 'user', 'content': 'Can you repeat my name?'} # uses session context
]
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=128,
messages=conversation
)
print(response.content[0].text) # expects: Your name is Alex.Strukturen til meldingshistorikken
Meldingshistorikken er ganske enkelt en liste med ordbøker, der hver ordbok har nøklene role og content.
Du administrerer denne listen selv i koden. Etter hvert svar fra assistenten legger du til svaret, deretter legger du til neste brukermelding – og sender hele listen på nytt ved neste kall.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
def chat(history, user_message):
history.append({'role': 'user', 'content': user_message})
response = client.chat.completions.create(
model='gpt-4o',
messages=history
)
reply = response.choices[0].message.content
history.append({'role': 'assistant', 'content': reply})
return reply, history
history = [{'role': 'system', 'content': 'You are a math tutor.'}]
reply, history = chat(history, 'What is a prime number?')
print(reply)
print('History length:', len(history))Tokenbegrensninger forklart
Hver modell har et kontekstvindu målt i tokens. Ett token tilsvarer omtrent 4 tegn eller 0,75 ord på engelsk.
Både inndataene dine (systemmelding + hele historikken) og modellens utdata teller med i denne grensen. GPT-4o støtter 128k tokens, mens Claude Opus 4.5 støtter 200k. Når grensen nås, må eldre meldinger fjernes eller oppsummeres.
import tiktoken
# Count tokens before sending to avoid exceeding the limit
encoding = tiktoken.encoding_for_model('gpt-4o')
messages = [
{'role': 'system', 'content': 'You are a helpful assistant.'},
{'role': 'user', 'content': 'Explain quantum entanglement in simple terms.'}
]
total_tokens = 0
for msg in messages:
total_tokens += len(encoding.encode(msg['content']))
total_tokens += 4 # overhead per message
print(f'Estimated input tokens: {total_tokens}')
print(f'GPT-4o limit: 128,000 tokens')
print(f'Budget remaining: {128000 - total_tokens:,} tokens')Hva skjer ved tokenbegrensningen
Når samtalehistorikken blir større enn kontekstvinduet, har du tre alternativer:
- Trunker — fjern de eldste meldingene
- Oppsummer — be modellen komprimere tidligere meldinger til et kort sammendrag
- Glidende vindu — behold bare de siste N meldingene
Hvis du velger feil strategi, kan modellen miste viktig kontekst og gi usammenhengende svar.
def trim_history(history, max_messages=10, keep_system=True):
'''Keep the system message and the last N non-system messages.'''
system_msgs = [m for m in history if m['role'] == 'system']
non_system = [m for m in history if m['role'] != 'system']
if len(non_system) > max_messages:
non_system = non_system[-max_messages:]
print(f'Trimmed to last {max_messages} messages.')
return system_msgs + non_system if keep_system else non_system
history = [{'role': 'system', 'content': 'You are a tutor.'}]
for i in range(15):
history.append({'role': 'user', 'content': f'Question {i}'})
history.append({'role': 'assistant', 'content': f'Answer {i}'})
trimmed = trim_history(history, max_messages=6)
print('Trimmed history length:', len(trimmed))Flere meldinger med kontekst i praksis
La oss se kontekst i praksis. I en flertrinnssamtale bruker modellen alle tidligere meldinger for å svare riktig på oppfølgingsspørsmål.
Derfor kan du si «forklar det enklere» uten å gjenta hva «det» viser til — modellen ser hele historikken og vet hva du refererte til.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
history = [{'role': 'system', 'content': 'You are a science teacher.'}]
# Turn 1
history.append({'role': 'user', 'content': 'What is photosynthesis?'})
r1 = client.chat.completions.create(model='gpt-4o', messages=history)
reply1 = r1.choices[0].message.content
history.append({'role': 'assistant', 'content': reply1})
# Turn 2 — refers to prior answer without repeating it
history.append({'role': 'user', 'content': 'Can you explain that using only 3 bullet points?'})
r2 = client.chat.completions.create(model='gpt-4o', messages=history)
print(r2.choices[0].message.content)Tilstandsløst API, tilstandsfull brukeropplevelse
Her er en viktig innsikt: API-et er helt tilstandsløst. Serveren husker ingenting mellom kallene.
Chatprodukter som ChatGPT skaper en illusjon av hukommelse ved å lagre samtalehistorikken i sin egen database og sette den inn igjen i hvert API-kall. Du kan bygge den samme mekanismen selv.
# Illustration: two isolated API calls vs one with history
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
# ❌ WITHOUT history — model has no memory
r1 = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': 'My dog is named Biscuit.'}]
)
r2 = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': "What's my dog's name?"}]
)
print('Without history:', r2.choices[0].message.content) # will not know
# ✅ WITH history injected
r3 = client.chat.completions.create(
model='gpt-4o',
messages=[
{'role': 'user', 'content': 'My dog is named Biscuit.'},
{'role': 'assistant', 'content': 'Got it, your dog is named Biscuit!'},
{'role': 'user', 'content': "What's my dog's name?"}
]
)
print('With history:', r3.choices[0].message.content)Praktiske tips for bruk av chatgrensesnittet
Følg disse rådene for å få mest mulig ut av chatgrensesnittet:
- Plasser varige instruksjoner i systemmeldingen i stedet for å gjenta dem i hver brukermelding
- Hold tidligere meldinger kortfattede — en omstendelig historikk bruker opp tokens raskt
- Start en ny økt når du bytter tema, for å unngå kontekstforurensning
- Sett bare inn det relevante utvalget av tidligere kontekst når du gjenopptar et langt prosjekt
# Good practice: compact system message + focused history
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
system = (
'You are a concise Python code reviewer. '
'Reply with: 1) one-line verdict, 2) top 3 issues, 3) fixed snippet.'
)
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=512,
system=system,
messages=[
{'role': 'user', 'content': 'def add(a,b): return a+b\nprint(add(1,2))'}
]
)
print(response.content[0].text)Oppsummering: Chatgrensesnittet
La oss gå gjennom hovedidéene bak hvordan chatgrensesnittet fungerer:
- Tre roller: systemet angir regler, brukeren sender prompter, og assistenten svarer
- Hele historikken sendes ved hvert API-kall — serveren er tilstandsløs
- Tokenbegrensninger setter en grense for den totale konteksten; forkort eller oppsummer når du nærmer deg grensen
- Øktens kontekst er bare en liste du håndterer i din egen kode
- Start nye økter når du bytter tema, slik at konteksten holdes ryddig
# Summary: minimal chat loop skeleton
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
history = [{'role': 'system', 'content': 'You are a helpful assistant.'}]
def ask(question):
history.append({'role': 'user', 'content': question})
res = client.chat.completions.create(model='gpt-4o', messages=history)
answer = res.choices[0].message.content
history.append({'role': 'assistant', 'content': answer})
return answer
print(ask('Hello! What can you help me with?'))Kunnskapstest
Test forståelsen din av hvordan chatgrensesnittet fungerer.
En bruker starter en helt ny økt og spør AI-en: «Hva diskuterte vi i går?» AI-en har ingen hukommelse fra gårsdagens økt. Hvorfor?
Dette har du lært
Du forstår nå grunnlaget for all AI-chat:
- Rollestrukturen system/bruker/assistent som former hver samtale
- Hvordan hele meldingshistorikken sendes ved hvert kall for å simulere hukommelse
- Hvorfor API-et er tilstandsløst, og hvordan chatprodukter bygger hukommelse oppå det
- Hvordan tokenbegrensninger setter rammer for konteksten, og hvordan du håndterer dem
Denne mentale modellen hjelper deg med å utforme bedre prompter og bygge smartere AI-drevne applikasjoner.
Lær deg AI-prompt engineering med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 53
- Leksjoner
- 199
Ofte stilte spørsmål
Er leksjonen «Forstå chatgrensesnittet» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien AI-prompt engineering, inkludert «Forstå chatgrensesnittet», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i AI-prompt engineering inneholder totalt 4 leksjoner.
Hva lærer jeg i «Forstå chatgrensesnittet»?
Slik fungerer chatgrensesnitt for LLM-er: roller, turer og øktkontekst. Du øver på AI-prompt engineering med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med AI-prompt engineering?
Ingen tidligere erfaring er nødvendig. AI-prompt engineering på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.
Hvor lang tid tar leksjonen «Forstå chatgrensesnittet»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne AI-prompt engineering-leksjonen?
Ja. Alle AI-prompt engineering-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Forstå chatgrensesnittet
- Typer forespørsler AI kan håndtere
- Slik genererer AI svar
- Hva AI ikke kan gjøre