AI Prompt Engineering · Aula

Entendendo a interface de conversa

Como funcionam as interfaces de conversa com LLM: papéis, turnos e contexto da sessão.

Entendendo a interface de conversa é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

Os Três Papéis

Toda conversa com um LLM é construída sobre três papéis: sistema, usuário e assistente.

O papel system define as regras e a personalidade antes do início da conversa. O papel user corresponde a você enviando mensagens. O papel assistant corresponde ao modelo respondendo.

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)

A Mensagem do Sistema

A mensagem do sistema é o manual de instruções do modelo. Ela é executada antes do primeiro turno do usuário e permanece ativa durante toda a sessão.

Use-a para definir a personalidade, o tom, as restrições de domínio ou o formato da saída. O modelo a considera seu contexto orientador durante toda a conversa.

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)

Turnos e Fluxo da Conversa

Uma conversa é uma sequência de turnos. Cada turno se alterna: o usuário fala, o assistente responde, e o usuário fala novamente.

O modelo vê todo o histórico de turnos a cada solicitação. É isso que faz a conversa parecer um diálogo contínuo — mas, tecnicamente, cada chamada à API não tem estado e recebe todo o contexto novamente.

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)

Contexto da Sessão

O contexto da sessão é a memória acumulada da sua conversa. Cada mensagem do usuário e do assistente é adicionada à matriz de histórico.

O modelo não tem um armazenamento de memória separado — ele raciocina exclusivamente a partir do que vê na janela de contexto atual. Se você iniciar uma nova sessão, o modelo não terá memória das sessões anteriores, a menos que você reinsira essas informações.

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.

Estrutura do Histórico de Mensagens

O histórico de mensagens é simplesmente uma lista de dicionários, cada um com uma chave role e uma chave content.

Você gerencia essa lista por conta própria no código. Após cada resposta do assistente, use append para adicionar a resposta dele e, em seguida, use append para adicionar a próxima mensagem do usuário — depois envie a lista inteira novamente na próxima chamada.

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

Limites de tokens explicados

Todo modelo tem uma janela de contexto medida em tokens. Um token corresponde aproximadamente a 4 caracteres ou 0,75 palavra em inglês.

Tanto a sua entrada (sistema + todo o histórico) quanto a saída do modelo contam para esse limite. O GPT-4o é compatível com 128 mil tokens; o Claude Opus 4.5 é compatível com 200 mil. Quando o limite é atingido, as mensagens mais antigas precisam ser removidas ou resumidas.

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

O que acontece ao atingir o limite de tokens

Quando o histórico da conversa ultrapassa a janela de contexto, você tem três opções:

Truncar — descartar as mensagens mais antigas
Resumir — pedir ao modelo que compacte as interações anteriores em um breve resumo
Janela deslizante — manter apenas as últimas N mensagens

Escolher a estratégia errada pode fazer o modelo perder um contexto crucial e fornecer respostas incoerentes.

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

Contexto em várias interações na prática

Vamos ver o contexto em ação. Em uma conversa com várias interações, o modelo usa todas as mensagens anteriores para responder corretamente às perguntas seguintes.

É por isso que você pode dizer “explique isso de forma mais simples” sem repetir o que era “isso”: o modelo vê todo o histórico e sabe ao que você se referiu.

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)

API sem estado, experiência do usuário com estado

Aqui está uma ideia fundamental: a API é completamente sem estado. O servidor não se lembra de nada entre as chamadas.

Aplicativos de conversa, como o ChatGPT, criam a ilusão de memória armazenando o histórico da conversa em seu próprio banco de dados e inserindo-o novamente em cada chamada à API. Você pode criar o mesmo mecanismo por conta própria.

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

Dicas práticas para usar a interface de conversa

Para aproveitar ao máximo a interface de conversa:

Coloque instruções persistentes na mensagem do sistema, em vez de repeti-las em cada interação do usuário
Mantenha as interações anteriores concisas — históricos longos consomem tokens rapidamente
Inicie uma nova sessão ao mudar de assunto para evitar a contaminação do contexto
Ao retomar um projeto longo, insira apenas o subconjunto relevante do contexto anterior

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

Recapitulação: a interface de conversa

Vamos revisar as ideias principais sobre o funcionamento da interface de conversa:

Três funções: o sistema define regras, o usuário envia instruções e o assistente responde
O histórico completo é enviado em cada chamada à API — o servidor não tem estado
Os limites de tokens restringem o contexto total; trunque ou resuma o conteúdo ao se aproximar deles
O contexto da sessão é apenas uma lista que você gerencia em seu próprio código
Inicie novas sessões ao mudar de assunto para manter o contexto organizado

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

Verificação de conhecimentos

Teste sua compreensão sobre o funcionamento da interface de conversa.

Um usuário inicia uma sessão totalmente nova e pergunta à IA: “O que discutimos ontem?” A IA não tem memória da sessão de ontem. Por quê?

O que você aprendeu

Agora você entende os fundamentos de toda interação de conversa com IA:

A estrutura de funções sistema/usuário/assistente que molda toda conversa
Como o histórico completo das mensagens é enviado em cada chamada para simular memória
Por que a API é sem estado e como os aplicativos de conversa criam memória sobre essa base
Como os limites de tokens restringem o contexto e como gerenciá-los

Esse modelo mental ajudará você a criar instruções melhores e aplicações mais inteligentes baseadas em IA.

Perguntas Frequentes

A aula “Entendendo a interface de conversa” é grátis?

Sim — o texto completo de “Entendendo a interface de conversa” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Entendendo a interface de conversa”?

Como funcionam as interfaces de conversa com LLM: papéis, turnos e contexto da sessão. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Entendendo a interface de conversa”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Entendendo a interface de conversa
Tipos de solicitações que a IA pode atender
Como a IA gera respostas
O que a IA não pode fazer

← Voltar para AI Prompt Engineering