Recapitulare: agentul de programări al unei clinici
Ai terminat primul modul. Acum pui totul cap la cap într-un agent mic, dar complet, pentru Clinica Sanavita: două tool-uri în lanț, o limită de pași, dispatch printr-un dicționar și un jurnal al rulării. La final verifici ce contează cu adevărat: programarea salvată în date, nu doar ce a spus modelul.
Ce ai învățat în modulul 1
| Lecția | Ideea | Când o folosești |
|---|---|---|
| Primul agent | modelul alege pașii, codul execută în buclă | cereri variate, pași necunoscuți dinainte |
| Cele patru piese | model, tool-uri, buclă, memorie (lista mesaje) | mereu: fără una dintre ele agentul se strică |
| Tool use pas cu pas | blocuri tool_use / tool_result legate prin id | la depanare, când primești 400 |
| Agent sau workflow | un apel, pași ficși cu poartă sau agent | alegi cel mai simplu nivel care merge |
| Rutarea | clasificator ieftin, handler-e specializate | cereri de câteva tipuri cunoscute |
| ReAct | gând, acțiune, observație | când vrei pași explicabili și jurnal |
| Tool-uri pentru agenți | nume, descriere cu „când”, enum, rezultate scurte | la fiecare tool pe care îl scrii |
Mini-proiectul: agentul clinicii
Pacienta Ioana Marin scrie: „Vreau o programare la dr. Pop marți.” Agentul trebuie să afle orele libere și apoi să facă programarea. Ordinea contează: programeaza acceptă doar o oră întoarsă de ore_libere. Tool-urile sunt scrise după regulile din lecția 7: descrieri cu „când”, enum pentru medic și zi.
Dispatch-ul, cu tool-uri necunoscute
Dacă modelul cere un nume care nu e în dicționar (rar, dar posibil după o greșeală în definiții), FUNCTII[nume] aruncă KeyError. Cu .get întorci un mesaj de eroare pe care îl poți trimite modelului cu is_error (detaliile, în modulul 2):
import anthropic
MODEL = "claude-haiku-5-5"
client = anthropic.Anthropic()
SYSTEM = ("Ești asistentul de programări al Clinicii Sanavita. Verifici întâi orele libere, apoi programezi "
"pacientul la prima oră liberă, cu numele lui complet.")
ORE = {("Pop", "marți"): ["10:00", "13:30"], ("Ionescu", "marți"): ["09:00"]}
PROGRAMARI = {} # starea reală: "medic zi ora" -> pacient
def ore_libere(medic, zi):
ore = ORE.get((medic, zi), [])
if not ore:
return f"Dr. {medic} nu are ore libere {zi}."
return f"Ore libere la dr. {medic} {zi}: {', '.join(ore)}"
def programeaza(medic, zi, ora, pacient):
if ora not in ORE.get((medic, zi), []):
return f"Ora {ora} nu mai este liberă la dr. {medic} {zi}. Verifică din nou orele libere."
ORE[(medic, zi)].remove(ora)
PROGRAMARI[f"{medic} {zi} {ora}"] = pacient
return f"Programare confirmată: dr. {medic}, {zi}, ora {ora}, pacient {pacient}"
ZILE = ["luni", "marți", "miercuri", "joi", "vineri"]
TOOLS = [
{"name": "ore_libere",
"description": "Orele libere ale unui medic într-o zi. Folosește-l când pacientul cere o programare, înainte de programeaza.",
"input_schema": {"type": "object", "properties": {
"medic": {"type": "string", "enum": ["Pop", "Ionescu"]}, "zi": {"type": "string", "enum": ZILE}},
"required": ["medic", "zi"]}},
{"name": "programeaza",
"description": "Face programarea la o oră întoarsă de ore_libere. Întoarce confirmarea sau motivul refuzului.",
"input_schema": {"type": "object", "properties": {
"medic": {"type": "string", "enum": ["Pop", "Ionescu"]}, "zi": {"type": "string", "enum": ZILE},
"ora": {"type": "string", "description": "de forma 10:00"}, "pacient": {"type": "string"}},
"required": ["medic", "zi", "ora", "pacient"]}},
]
CERERE = "Bună ziua, sunt Ioana Marin. Vreau o programare la dr. Pop marți."
def text_din(raspuns):
return " ".join(b.text for b in raspuns.content if b.type == "text")
FUNCTII = {"ore_libere": ore_libere, "programeaza": programeaza}
def executa(nume, intrare):
functie = FUNCTII.get(nume)
if functie is None:
return f"Tool necunoscut: {nume}", True
return functie(**intrare), False
print(executa("ore_libere", {"medic": "Ionescu", "zi": "marți"}))
print(executa("anuleaza", {"id": 7}))
('Ore libere la dr. Ionescu marți: 09:00', False)
('Tool necunoscut: anuleaza', True)Limita de pași în acțiune
Ca să vezi ce face limita, iată bucla cu MAX_PASI = 1. Agentul apucă să afle orele libere, dar nu și să programeze, iar else-ul buclei for (rulat doar când bucla nu s-a oprit cu break) raportează oprirea:
import anthropic
MODEL = "claude-haiku-5-5"
client = anthropic.Anthropic()
SYSTEM = ("Ești asistentul de programări al Clinicii Sanavita. Verifici întâi orele libere, apoi programezi "
"pacientul la prima oră liberă, cu numele lui complet.")
ORE = {("Pop", "marți"): ["10:00", "13:30"], ("Ionescu", "marți"): ["09:00"]}
PROGRAMARI = {} # starea reală: "medic zi ora" -> pacient
def ore_libere(medic, zi):
ore = ORE.get((medic, zi), [])
if not ore:
return f"Dr. {medic} nu are ore libere {zi}."
return f"Ore libere la dr. {medic} {zi}: {', '.join(ore)}"
def programeaza(medic, zi, ora, pacient):
if ora not in ORE.get((medic, zi), []):
return f"Ora {ora} nu mai este liberă la dr. {medic} {zi}. Verifică din nou orele libere."
ORE[(medic, zi)].remove(ora)
PROGRAMARI[f"{medic} {zi} {ora}"] = pacient
return f"Programare confirmată: dr. {medic}, {zi}, ora {ora}, pacient {pacient}"
ZILE = ["luni", "marți", "miercuri", "joi", "vineri"]
TOOLS = [
{"name": "ore_libere",
"description": "Orele libere ale unui medic într-o zi. Folosește-l când pacientul cere o programare, înainte de programeaza.",
"input_schema": {"type": "object", "properties": {
"medic": {"type": "string", "enum": ["Pop", "Ionescu"]}, "zi": {"type": "string", "enum": ZILE}},
"required": ["medic", "zi"]}},
{"name": "programeaza",
"description": "Face programarea la o oră întoarsă de ore_libere. Întoarce confirmarea sau motivul refuzului.",
"input_schema": {"type": "object", "properties": {
"medic": {"type": "string", "enum": ["Pop", "Ionescu"]}, "zi": {"type": "string", "enum": ZILE},
"ora": {"type": "string", "description": "de forma 10:00"}, "pacient": {"type": "string"}},
"required": ["medic", "zi", "ora", "pacient"]}},
]
CERERE = "Bună ziua, sunt Ioana Marin. Vreau o programare la dr. Pop marți."
def text_din(raspuns):
return " ".join(b.text for b in raspuns.content if b.type == "text")
MAX_PASI = 1 # intenționat prea mic, ca să vezi oprirea
mesaje = [{"role": "user", "content": CERERE}]
for pas in range(1, MAX_PASI + 1):
raspuns = client.messages.create(model=MODEL, max_tokens=500, system=SYSTEM, tools=TOOLS, messages=mesaje)
if raspuns.stop_reason != "tool_use":
break
mesaje.append({"role": "assistant", "content": raspuns.content})
bloc = next(b for b in raspuns.content if b.type == "tool_use")
print(f"Pas {pas}: {bloc.name} {bloc.input}")
mesaje.append({"role": "user", "content": [{"type": "tool_result", "tool_use_id": bloc.id,
"content": ore_libere(**bloc.input)}]})
else:
print(f"Oprit după {MAX_PASI} pas: limita atinsă, sarcina nu e terminată.")
print("Programări:", PROGRAMARI)
Pas 1: ore_libere {'medic': 'Pop', 'zi': 'marți'}
Oprit după 1 pas: limita atinsă, sarcina nu e terminată.
Programări: {}Observă Programări: {}: modelul nu a programat nimic, deci nici aplicația nu trebuie să spună „programare făcută”. Statusul limita duce cererea la un om. În producție, limita tipică e de 10-20 de pași, în funcție de sarcină.
Greșeli frecvente
- Crezi textul, nu starea. Modelul poate spune „v-am programat” chiar dacă tool-ul a întors o eroare. Raportul final al aplicației se face din PROGRAMARI.
- Bucla fără limită. Un rezultat ambiguu („ora nu mai e liberă”) poate face modelul să încerce iar și iar. MAX_PASI te protejează de bucle infinite și de facturi mari.
- Programezi fără să verifici ora. Tool-ul programeaza verifică singur că ora e în ORE; nu lăsa validarea doar pe seama modelului.
- Jurnalul doar cu numele tool-urilor. Fără argumente și rezultate nu poți afla de ce a ales agentul ora greșită.
Agenți de programări în lumea reală
Ore libere, programare, reamintire prin SMS: aceeași buclă, cu un tool în plus.
Caută mașina după număr, verifică ce revizie urmează și programează la primul elevator liber.
Camere libere în perioada cerută, prețul, rezervarea și confirmarea pe email.
Construiește agentul de programări al Clinicii Sanavita. Datele, tool-urile și funcțiile sunt în starter; scrie dispatch-ul, funcția ruleaza cu limită de pași și jurnal, apoi afișează jurnalul, starea reală (programările și orele rămase) și răspunsul.
- Completează FUNCTII cu cele două tool-uri: "ore_libere" și "programeaza".
- Scrie ruleaza(cerere): cel mult MAX_PASI apeluri (for pas in range(1, MAX_PASI + 1)); la stop_reason diferit de tool_use întoarce ("gata", text_din(raspuns)).
- La fiecare tool_use: execută prin FUNCTII[bloc.name], adaugă în jurnal linia f"{pas}. {bloc.name}({bloc.input}) -> {rezultat}" și trimite rezultatele într-un singur mesaj user.
- După buclă întoarce ("limita", "Nu am reușit să termin programarea, vă sună un coleg.").
- Afișează Jurnal: și liniile jurnalului (cu două spații în față, de exemplu print(" ", linie)), apoi Programări: ..., Ore rămase la dr. Pop marți: ..., Status: ... și Răspuns: ....
Soluția exercițiului
import anthropic
MODEL = "claude-haiku-5-5"
client = anthropic.Anthropic()
SYSTEM = ("Ești asistentul de programări al Clinicii Sanavita. Verifici întâi orele libere, apoi programezi "
"pacientul la prima oră liberă, cu numele lui complet.")
ORE = {("Pop", "marți"): ["10:00", "13:30"], ("Ionescu", "marți"): ["09:00"]}
PROGRAMARI = {} # starea reală: "medic zi ora" -> pacient
def ore_libere(medic, zi):
ore = ORE.get((medic, zi), [])
if not ore:
return f"Dr. {medic} nu are ore libere {zi}."
return f"Ore libere la dr. {medic} {zi}: {', '.join(ore)}"
def programeaza(medic, zi, ora, pacient):
if ora not in ORE.get((medic, zi), []):
return f"Ora {ora} nu mai este liberă la dr. {medic} {zi}. Verifică din nou orele libere."
ORE[(medic, zi)].remove(ora)
PROGRAMARI[f"{medic} {zi} {ora}"] = pacient
return f"Programare confirmată: dr. {medic}, {zi}, ora {ora}, pacient {pacient}"
ZILE = ["luni", "marți", "miercuri", "joi", "vineri"]
TOOLS = [
{"name": "ore_libere",
"description": "Orele libere ale unui medic într-o zi. Folosește-l când pacientul cere o programare, înainte de programeaza.",
"input_schema": {"type": "object", "properties": {
"medic": {"type": "string", "enum": ["Pop", "Ionescu"]}, "zi": {"type": "string", "enum": ZILE}},
"required": ["medic", "zi"]}},
{"name": "programeaza",
"description": "Face programarea la o oră întoarsă de ore_libere. Întoarce confirmarea sau motivul refuzului.",
"input_schema": {"type": "object", "properties": {
"medic": {"type": "string", "enum": ["Pop", "Ionescu"]}, "zi": {"type": "string", "enum": ZILE},
"ora": {"type": "string", "description": "de forma 10:00"}, "pacient": {"type": "string"}},
"required": ["medic", "zi", "ora", "pacient"]}},
]
CERERE = "Bună ziua, sunt Ioana Marin. Vreau o programare la dr. Pop marți."
def text_din(raspuns):
return " ".join(b.text for b in raspuns.content if b.type == "text")
MAX_PASI = 5
FUNCTII = {"ore_libere": ore_libere, "programeaza": programeaza}
jurnal = []
def ruleaza(cerere):
mesaje = [{"role": "user", "content": cerere}]
for pas in range(1, MAX_PASI + 1):
raspuns = client.messages.create(model=MODEL, max_tokens=500, system=SYSTEM, tools=TOOLS, messages=mesaje)
if raspuns.stop_reason != "tool_use":
return "gata", text_din(raspuns)
mesaje.append({"role": "assistant", "content": raspuns.content})
rezultate = []
for bloc in raspuns.content:
if bloc.type == "tool_use":
rezultat = FUNCTII[bloc.name](**bloc.input)
jurnal.append(f"{pas}. {bloc.name}({bloc.input}) -> {rezultat}")
rezultate.append({"type": "tool_result", "tool_use_id": bloc.id, "content": rezultat})
mesaje.append({"role": "user", "content": rezultate})
return "limita", "Nu am reușit să termin programarea, vă sună un coleg."
status, text = ruleaza(CERERE)
print("Jurnal:")
for linie in jurnal:
print(" ", linie)
print(f"Programări: {PROGRAMARI}")
print(f"Ore rămase la dr. Pop marți: {ORE[('Pop', 'marți')]}")
print(f"Status: {status}")
print(f"Răspuns: {text}") 