Comprendere l'interfaccia di chat
Come funzionano le interfacce di chat degli LLM: ruoli, turni e contesto della sessione
Comprendere l'interfaccia di chat è una lezione AI Prompt Engineering gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Prompt Engineering, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Prompt Engineering include 4 lezioni in totale.
I tre ruoli
Ogni conversazione con un LLM si basa su tre ruoli: system, user e assistant.
Il ruolo system definisce le regole e la persona prima dell'inizio della conversazione. Il ruolo user rappresenta Lei quando invia messaggi. Il ruolo assistant rappresenta il modello quando risponde.
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)Il messaggio di sistema
Il messaggio di sistema è il manuale di istruzioni del modello. Viene eseguito prima del primo turno dell'utente e rimane attivo per tutta la sessione.
Lo utilizzi per impostare la persona, il tono, le restrizioni di dominio o il formato dell'output. Il modello lo tratta come contesto guida per tutta la conversazione.
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)Turni e flusso della conversazione
Una conversazione è una sequenza di turni. Ogni turno si alterna: parla l'utente, risponde l'assistant, poi parla di nuovo l'utente.
Il modello vede l'intera cronologia dei turni a ogni richiesta. È ciò che dà l'impressione di un dialogo continuo, ma tecnicamente ogni chiamata API è stateless e riceve ogni volta l'intero contesto.
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)Contesto della sessione
Il contesto della sessione è la memoria corrente della conversazione. Ogni messaggio dell'utente e dell'assistant si accumula nell'array history.
Il modello non dispone di un archivio di memoria separato: ragiona esclusivamente sulla base di ciò che vede nella finestra di contesto corrente. Se avvia una nuova sessione, il modello non ricorda le sessioni precedenti, a meno che Lei non inserisca nuovamente tali informazioni.
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.Struttura della cronologia dei messaggi
La cronologia dei messaggi è semplicemente una lista di dizionari, ognuno con una chiave role e una chiave content.
Gestisce personalmente questa lista nel codice. Dopo ogni risposta dell'assistant aggiunge la relativa risposta, quindi aggiunge il messaggio successivo dell'utente e invia di nuovo l'intera lista nella chiamata successiva.
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))Limiti dei token spiegati
Ogni modello dispone di una finestra di contesto misurata in token. Un token corrisponde indicativamente a 4 caratteri o a 0,75 parole in inglese.
Sia l'input (messaggio di sistema + cronologia completa) sia l'output del modello contribuiscono a questo limite. GPT-4o supporta 128k token; Claude Opus 4.5 ne supporta 200k. Quando si raggiunge il limite, i messaggi più vecchi devono essere rimossi o riassunti.
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')Cosa succede al raggiungimento del limite dei token
Quando la cronologia della conversazione supera la finestra di contesto, sono disponibili tre opzioni:
- Troncare — eliminare i messaggi più vecchi
- Riassumere — chiedere al modello di condensare i turni precedenti in un breve riepilogo
- Finestra scorrevole — mantenere solo gli ultimi N messaggi
Scegliere la strategia sbagliata può far perdere al modello il contesto fondamentale e indurlo a fornire risposte incoerenti.
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))Il contesto multi-turno nella pratica
Vediamo il contesto in azione. In una conversazione a più turni, il modello usa ogni messaggio precedente per rispondere correttamente alle domande successive.
Ecco perché può dire «spiegalo in modo più semplice» senza dover ripetere a cosa si riferisse quel «lo»: il modello vede l'intera cronologia e sa a cosa si riferisce.
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 senza stato, UX con stato
Ecco un concetto fondamentale: l'API è completamente senza stato. Il server non conserva nulla tra una chiamata e l'altra.
I prodotti di chat come ChatGPT creano l'illusione della memoria memorizzando la cronologia della conversazione nel proprio database e reinserendola in ogni chiamata API. Può costruire lo stesso meccanismo autonomamente.
# 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)Consigli pratici per usare l'interfaccia di chat
Per ottenere il massimo dall'interfaccia di chat:
- Inserisca le istruzioni persistenti nel messaggio di sistema, invece di ripeterle in ogni turno dell'utente
- Mantenga concisi i turni precedenti — una cronologia prolissa consuma rapidamente i token
- Avvii una nuova sessione quando cambia argomento, per evitare di contaminare il contesto
- Inserisca solo il sottoinsieme pertinente del contesto precedente quando riprende un progetto lungo
# 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)Riepilogo: l'interfaccia di chat
Esaminiamo le idee fondamentali sul funzionamento dell'interfaccia di chat:
- Tre ruoli: system definisce le regole, user invia i prompt, assistant risponde
- La cronologia completa viene inviata a ogni chiamata API: il server è senza stato
- I limiti dei token impongono un limite al contesto totale; quando ci si avvicina, lo si riduce o riassume
- Il contesto della sessione è semplicemente un elenco che gestisce nel proprio codice
- Avvii una nuova sessione quando cambia argomento, per mantenere pulito il contesto
# 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 delle conoscenze
Verifichi la propria comprensione del funzionamento dell'interfaccia di chat.
Un utente avvia una sessione completamente nuova e chiede all'IA: «Di cosa abbiamo parlato ieri?» L'IA non ha memoria della sessione di ieri. Perché?
Che cosa ha appreso
Ora comprende i fondamenti di ogni interazione con una chat IA:
- La struttura dei ruoli system/user/assistant che dà forma a ogni conversazione
- Il modo in cui la cronologia completa dei messaggi viene inviata a ogni chiamata per simulare la memoria
- Perché l'API è senza stato e come i prodotti di chat costruiscono la memoria su questa base
- In che modo i limiti dei token restringono il contesto e come gestirli
Questo modello mentale La aiuterà a scrivere prompt migliori e a creare applicazioni più intelligenti basate sull'IA.
Domande Frequenti
La lezione «Comprendere l'interfaccia di chat» è gratuita?
Sì — il testo completo di «Comprendere l'interfaccia di chat» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Prompt Engineering, passa a CoddyKit PRO. Il corso AI Prompt Engineering include 4 lezioni in totale.
Cosa imparerò in «Comprendere l'interfaccia di chat»?
Come funzionano le interfacce di chat degli LLM: ruoli, turni e contesto della sessione Eserciti AI Prompt Engineering con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Prompt Engineering?
Non è richiesta alcuna esperienza precedente. AI Prompt Engineering su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Comprendere l'interfaccia di chat»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Prompt Engineering?
Sì. Ogni lezione AI Prompt Engineering include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Comprendere l'interfaccia di chat
- Tipi di richieste che l'IA può gestire
- Come l'IA genera le risposte
- Cosa non può fare l'IA