Die Chat-Oberfläche verstehen

Die drei Rollen

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)

Die Systemnachricht

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)

Turns und Gesprächsablauf

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)

Sitzungskontext

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.

Struktur des Nachrichtenverlaufs

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))

Token-Limits erklärt

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')

Was beim Erreichen des Token-Limits geschieht

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))

Multi-Turn-Kontext in der Praxis

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)

Zustandslose API, zustandsbehaftete UX

# 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)

Praktische Tipps zur Verwendung der Chat-Oberfläche

# 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)

Zusammenfassung: Die Chat-Oberfläche

# 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?'))

Wissenscheck

Das haben Sie gelernt