...
← Curs Agenți AI și MCP: toate lecțiile
Lecția 8 · Ce este un agent AI

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țiaIdeeaCând o folosești
Primul agentmodelul alege pașii, codul execută în buclăcereri variate, pași necunoscuți dinainte
Cele patru piesemodel, tool-uri, buclă, memorie (lista mesaje)mereu: fără una dintre ele agentul se strică
Tool use pas cu pasblocuri tool_use / tool_result legate prin idla depanare, când primești 400
Agent sau workflowun apel, pași ficși cu poartă sau agentalegi cel mai simplu nivel care merge
Rutareaclasificator ieftin, handler-e specializatecereri de câteva tipuri cunoscute
ReActgând, acțiune, observațiecând vrei pași explicabili și jurnal
Tool-uri pentru agenținume, descriere cu „când”, enum, rezultate scurtela 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.

ruleaza(cerere): cel mult MAX_PASI = 5 apeluri la model, apoi status „limita”Pacienta„dr. Pop marți”pas 1ore_libere10:00, 13:30pas 2programeaza10:00, Ioana MarinRăspunsstatus: gataStarea reală (codul tău)PROGRAMARI = {"Pop marți 10:00": "Ioana Marin"}ORE[("Pop", "marți")] = ["13:30"]jurnal: fiecare pascu input și rezultat
Agentul clinicii: doi pași în lanț în limita MAX_PASI, efectul real în PROGRAMARI și ORE, jurnalul fiecărui pas și statusul rulării.
1
Dispatch: un dicționar FUNCTII nume → funcție, în loc de if bloc.name == .... Adaugi un tool nou cu o singură linie.
2
Limita de pași: for pas in range(1, MAX_PASI + 1) în loc de while True. Un agent fără limită poate rula la nesfârșit (și costa) dacă modelul repetă un pas.
3
Statusul rulării: funcția întoarce ("gata", text) sau ("limita", mesaj pentru om), ca aplicația să știe ce s-a întâmplat.
4
Jurnalul: fiecare pas cu tool-ul, argumentele și rezultatul. Îl citești când ceva nu merge.
5
Starea reală: verifici în PROGRAMARI că programarea există, nu te bazezi pe textul „Gata, sunteți programată”.

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: {}
Important

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ă

ClinicăProgramări online

Ore libere, programare, reamintire prin SMS: aceeași buclă, cu un tool în plus.

Service autoRevizii

Caută mașina după număr, verifică ce revizie urmează și programează la primul elevator liber.

HotelRezervări

Camere libere în perioada cerută, prețul, rezervarea și confirmarea pe email.

Exercițiul tău

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: ....
Ai toate piesele în lecțiile 1-3; diferența e for pas in range(...) în loc de while True și return în loc de break.

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}")
Excelent! Continuă cu lecția următoare →
main.pyPython
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Ce este un agent AI Lecția 8 · Recapitulare: agentul de programări al unei clinici
Progres 0% 0 din 10
Lecția curentă 8 / 8 Ce este un agent ai