100 de exerciții rezolvate Aplicații AI cu LLM, cu soluții
Exerciții Aplicații AI cu LLM de la ușor la greu, fiecare cu cerința, un indiciu, soluția completă și explicația ei. Înveți de la zero cu Curs Aplicații AI cu Claude și OpenAI: primele 8 lecții sunt gratuite.
Le rezolvi direct pe pagină, în editorul Python, exact ca în lecțiile cursului: scrii, apeși Verifică și afli imediat dacă e corect.
Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Pe pagina asta exersezi construirea de aplicații reale cu modele de limbaj, prin API: primele apeluri la Claude și OpenAI, prompturi clare cu ieșire JSON validată, conversații cu istoric și streaming, tool use, RAG cu embeddings și citarea surselor, agenți cu bucle de tool-uri, controlul costurilor, tratarea erorilor, caching și securitate. Situațiile sunt cele pe care le întâlnești în proiecte: chatbotul unui magazin, clasificarea tichetelor de suport, extragerea datelor din facturi, rezumatul unui contract, asistentul intern al unei firme.
Exercițiile sunt grupate pe capitole și merg de la ușor la greu în fiecare capitol. Fiecare exercițiu se rezolvă direct în pagină, în Python, cu SDK-urile anthropic și openai: apelurile ajung la un simulator al API-ului, care răspunde mereu la fel, deci nu ai nevoie de cheie API și rezultatul se poate verifica exact. Scrii codul, îl rulezi și compari cu soluția, care conține codul complet, prompturile și explicația. Codul rămâne același și cu API-ul real; acolo, textele generate de model diferă puțin de la o rulare la alta.
Harta exercițiilor
Trei insule, de la ușor la greu. Omulețul stă la exercițiul la care ai rămas: apasă pe orice exercițiu deschis ca să-l rezolvi.
Primele apeluri la API: mesaje, system prompt, max_tokens
1UșorGratuit Rezolvat
Trimite primul mesaj către Claude și afișează răspunsul
Scrie un program Python care trimite o întrebare către Claude și afișează răspunsul, motivul opririi și tokenii consumați.
Întrebarea este scrisă direct în cod: Dă-mi 3 idei de nume pentru o cafenea mică din Brașov. Folosește SDK-ul anthropic, modelul claude-haiku-5-5 pus în constanta MODEL și maximum 300 de tokeni de răspuns. Cheia API nu se scrie în cod: clientul o citește singur din variabila de mediu ANTHROPIC_API_KEY (în pagină, API-ul este simulat și merge fără cheie).
Programul afișează textul răspunsului (lipit din blocurile de tip text), apoi pe linii separate stop_reason: ..., tokeni intrare: ... și tokeni ieșire: ....
Rezultatul așteptat
1. Cafeneaua de sub Tâmpa
2. Boabe și Brazi
3. Colțul Șchei
stop_reason: end_turn
tokeni intrare: 26
tokeni ieșire: 22
Indiciu
Clientul se uită singur după ANTHROPIC_API_KEY; ție îți rămân doar model, max_tokens și messages.
Soluția
PYTHON
import anthropic
MODEL = "claude-haiku-5-5"
client = anthropic.Anthropic() # citește ANTHROPIC_API_KEY din mediu
raspuns = client.messages.create(
model=MODEL,
max_tokens=300,
messages=[
{"role": "user", "content": "Dă-mi 3 idei de nume pentru o cafenea mică din Brașov."}
],
)
text = "".join(b.text for b in raspuns.content if b.type == "text")
print(text)
print("stop_reason:", raspuns.stop_reason)
print("tokeni intrare:", raspuns.usage.input_tokens)
print("tokeni ieșire:", raspuns.usage.output_tokens)
Explicația
Un apel la Messages API are trei parametri obligatorii: model, max_tokens și messages, o listă de mesaje cu role și content. Primul mesaj trebuie să fie de la user.
Răspunsul nu este un simplu șir de caractere: raspuns.content este o listă de blocuri. Un bloc de tip text are câmpul .text; alte tipuri (de exemplu tool_use) apar când folosești tool-uri. De aceea lipim textul doar din blocurile de tip text, în loc să presupunem că primul bloc e mereu text.
stop_reason spune de ce s-a oprit modelul: end_turn înseamnă că a terminat natural; max_tokens ar însemna că răspunsul a fost tăiat. usage îți dă tokenii pe care îi plătești.
Greșeala tipică: cheia scrisă direct în cod și urcată pe GitHub. Ține-o într-o variabilă de mediu, iar modelul într-o constantă, ca să-l schimbi dintr-un singur loc.
Scrie un system prompt pentru asistentul unei pizzerii
Creează un asistent pentru o pizzerie care răspunde doar despre meniu și comenzi, folosind parametrul system.
Pizzeria „La Cuptor” are în meniu: Margherita 32 lei, Diavola 38 lei, Quattro Formaggi 41 lei. Livrarea durează în jur de 40 de minute. Asistentul vorbește politicos, în română, răspunde în cel mult 3 propoziții și, dacă e întrebat despre altceva decât pizzeria, spune că poate ajuta doar cu meniul și comenzile. Toate aceste reguli și date stau în constanta SYSTEM, nu în mesajul clientului.
Trimite cele două întrebări din INTREBARI, fiecare într-un apel separat, și afișează pentru fiecare Client: <întrebare>, apoi Asistent: <răspuns> și o linie goală.
Rezultatul așteptat
Client: Cât costă o Diavola?
Asistent: Pizza Diavola costă 38 lei. Livrarea durează în jur de 40 de minute.
Client: Cine a câștigat aseară meciul?
Asistent: Îmi pare rău, pot ajuta doar cu meniul și comenzile pizzeriei „La Cuptor”.
Indiciu
Regulile și datele fixe ale aplicației stau în system, nu în mesajul utilizatorului.
Soluția
PYTHON
import anthropic
MODEL = "claude-haiku-5-5"
SYSTEM = """Ești asistentul pizzeriei „La Cuptor”. Răspunzi politicos, în română, în cel mult 3 propoziții.
Meniul:
- Margherita: 32 lei
- Diavola: 38 lei
- Quattro Formaggi: 41 lei
Livrarea durează în jur de 40 de minute.
Răspunzi doar la întrebări despre meniu și comenzi. Dacă ești întrebat despre altceva, spui că poți ajuta doar cu meniul și comenzile pizzeriei."""
INTREBARI = ["Cât costă o Diavola?", "Cine a câștigat aseară meciul?"]
client = anthropic.Anthropic()
def intreaba(intrebare):
raspuns = client.messages.create(
model=MODEL,
max_tokens=200,
system=SYSTEM,
messages=[{"role": "user", "content": intrebare}],
)
return "".join(b.text for b in raspuns.content if b.type == "text")
for intrebare in INTREBARI:
print("Client:", intrebare)
print("Asistent:", intreaba(intrebare))
print()
Explicația
Parametrul system este locul pentru tot ce rămâne constant în aplicație: cine este asistentul, ce date are (meniul, prețurile), cum vorbește și ce nu face. Mesajele din messages sunt doar conversația cu clientul.
Am pus meniul direct în system prompt pentru că modelul nu știe prețurile pizzeriei tale; fără ele ar inventa cifre plauzibile. Regula pentru întrebări din afara subiectului îi dă modelului o frază clară de folosit, în loc să-l lași să improvizeze.
Greșeala tipică: system prompt-ul pus ca mesaj cu "role": "system" în lista messages. Messages API de la Claude acceptă în messages doar rolurile user și assistant și răspunde cu eroare 400; system prompt-ul este un parametru separat. Testează mereu și un caz „rău” (întrebarea despre meci), nu doar cazul fericit.
Cere modelului o descriere lungă cu max_tokens=40 și detectează dacă răspunsul a fost tăiat.
Scrie funcția intreaba(intrebare, max_tokens) care trimite întrebarea, afișează textul primit, apoi, dacă stop_reason este max_tokens, afișează Răspuns incomplet: mărește max_tokens sau cere un text mai scurt., altfel Răspuns complet., iar la final o linie de 40 de cratime.
Apeleaz-o de două ori, cu aceeași limită de 40: întâi cu Explică pe larg cum funcționează un card de debit., apoi cu cerința reformulată ca să încapă: Explică în 2 propoziții scurte cum funcționează un card de debit.
Rezultatul așteptat
Un card de debit este legat direct de contul tău curent. Când plătești la un comerciant, terminalul trimite cererea către bancă,
Răspuns incomplet: mărește max_tokens sau cere un text mai scurt.
----------------------------------------
Cardul de debit e legat de contul tău curent. Când plătești, suma se scade imediat din banii pe care îi ai în cont.
Răspuns complet.
----------------------------------------
Indiciu
Limita din max_tokens taie răspunsul brusc, nu îl scurtează frumos; scurtarea o ceri prin instrucțiuni.
Soluția
PYTHON
import anthropic
MODEL = "claude-haiku-5-5"
client = anthropic.Anthropic()
def intreaba(intrebare, max_tokens):
raspuns = client.messages.create(
model=MODEL,
max_tokens=max_tokens,
messages=[{"role": "user", "content": intrebare}],
)
text = "".join(b.text for b in raspuns.content if b.type == "text")
print(text)
if raspuns.stop_reason == "max_tokens":
print("Răspuns incomplet: mărește max_tokens sau cere un text mai scurt.")
else:
print("Răspuns complet.")
print("-" * 40)
intreaba("Explică pe larg cum funcționează un card de debit.", 40)
intreaba("Explică în 2 propoziții scurte cum funcționează un card de debit.", 40)
Explicația
max_tokens este o limită de siguranță pentru cost și pentru timp: modelul se oprește când ajunge la ea, chiar și în mijlocul unui cuvânt. Nu este o instrucțiune de stil, modelul nu își „planifică” răspunsul ca să încapă.
De aceea verifici mereu stop_reason. Valoarea max_tokens îți spune că textul e tăiat și nu trebuie arătat clientului ca și cum ar fi complet (sau, la JSON, că nu se va putea parsa). Valoarea end_turn înseamnă că modelul a terminat singur.
Lungimea dorită se controlează prin cerință: „în 2 propoziții”, „maximum 50 de cuvinte”. Combinația corectă în producție este o instrucțiune clară de lungime plus un max_tokens cu o rezervă generoasă peste ce aștepți. Greșeala tipică este să pui o limită mică pentru a economisi și să afișezi apoi fraze rupte.
Afișează câți tokeni a consumat un apel și cât a costat
Calculează costul unui apel din usage, știind prețul modelului: 0,10 $ pe milion de tokeni de intrare și 0,50 $ pe milion de tokeni de ieșire (constantele PRET_INTRARE și PRET_IESIRE din cod).
Trimite cerința Scrie un mesaj scurt de mulțumire pentru un client care a lăsat o recenzie de 5 stele. cu max_tokens=200. Citește din răspuns tokenii de intrare și de ieșire și calculează costul în dolari.
Afișează textul răspunsului, apoi Intrare: X tokeni, ieșire: Y tokeni, cost: Z $, cu costul cu 8 zecimale.
Rezultatul așteptat
Mulțumim din suflet pentru cele 5 stele! Ne bucurăm că ți-a plăcut experiența și te așteptăm cu drag din nou.
Intrare: 36 tokeni, ieșire: 35 tokeni, cost: 0.00002110 $
Indiciu
Costul este tokeni împărțiți la un milion, înmulțiți cu prețul, separat pentru intrare și ieșire.
Soluția
PYTHON
import anthropic
MODEL = "claude-haiku-5-5"
PRET_INTRARE = 0.10 # $ pe 1.000.000 tokeni de intrare
PRET_IESIRE = 0.50 # $ pe 1.000.000 tokeni de ieșire
client = anthropic.Anthropic()
raspuns = client.messages.create(
model=MODEL,
max_tokens=200,
messages=[{
"role": "user",
"content": "Scrie un mesaj scurt de mulțumire pentru un client care a lăsat o recenzie de 5 stele.",
}],
)
tin = raspuns.usage.input_tokens
tout = raspuns.usage.output_tokens
cost = tin / 1_000_000 * PRET_INTRARE + tout / 1_000_000 * PRET_IESIRE
print(raspuns.content[0].text)
print(f"Intrare: {tin} tokeni, ieșire: {tout} tokeni, cost: {cost:.8f} $")
Explicația
API-urile de LLM se taxează pe tokeni, iar tokenii de ieșire sunt de obicei mai scumpi decât cei de intrare (aici de 5 ori). De aceea calculezi cele două părți separat și le aduni.
Câmpul usage din răspuns conține exact tokenii facturați: input_tokens (system prompt, istoric, întrebare) și output_tokens (textul generat). Nu îi estima numărând cuvinte; folosește valorile din răspuns.
Un singur apel costă o fracțiune infimă, de aceea afișăm 8 zecimale. Contează însă la scară: înmulțit cu mii de clienți și zeci de mesaje pe zi, costul devine real. Prețurile stau în constante pentru că diferă de la model la model și se pot schimba; verifică mereu pagina oficială de prețuri. Greșeala tipică: folosirea aceluiași preț pentru intrare și ieșire, ceea ce subestimează costul aplicațiilor care generează texte lungi.
Generează descrieri de produs pentru un magazin online
Generează automat câte o descriere scurtă pentru fiecare produs din lista PRODUSE, cu câte un apel la model pentru fiecare.
Fiecare descriere are 2 propoziții, ton prietenos, în română, fără superlative de tipul „cel mai bun”. Regulile stau în system prompt (constanta SYSTEM), iar produsul în mesajul utilizatorului, sub forma Produs: <nume>.
Afișează pentru fiecare produs numele, pe linia următoare descrierea (precedată de 3 spații), iar la final Tokeni de ieșire în total: N, suma tokenilor de ieșire ai celor trei apeluri.
Rezultatul așteptat
Rucsac impermeabil 25 L, negru
Cu 25 de litri, ai loc pentru tot ce îți trebuie într-o zi pe munte. Materialul impermeabil îți ține lucrurile uscate și pe ploaie.
Termos din oțel inoxidabil 750 ml
Îți iei cafeaua sau ceaiul la drum în 750 ml de oțel inoxidabil. E ușor de curățat și rezistă la drumuri lungi.
Lanternă frontală reîncărcabilă USB-C
Ai mâinile libere și lumină exact unde te uiți. O încarci cu același cablu USB-C ca telefonul.
Tokeni de ieșire în total: 112
Indiciu
Același system prompt, un apel în buclă pentru fiecare produs, iar tokenii îi aduni într-o variabilă.
Soluția
PYTHON
import anthropic
MODEL = "claude-haiku-5-5"
SYSTEM = """Scrii descrieri de produs pentru un magazin online de echipament outdoor.
Reguli:
- exact 2 propoziții, în română
- ton prietenos, la persoana a II-a
- fără superlative de tipul „cel mai bun” sau „perfect”
- nu inventa caracteristici care nu apar în numele produsului"""
PRODUSE = [
"Rucsac impermeabil 25 L, negru",
"Termos din oțel inoxidabil 750 ml",
"Lanternă frontală reîncărcabilă USB-C",
]
client = anthropic.Anthropic()
total_iesire = 0
for produs in PRODUSE:
raspuns = client.messages.create(
model=MODEL,
max_tokens=150,
system=SYSTEM,
messages=[{"role": "user", "content": f"Produs: {produs}"}],
)
total_iesire += raspuns.usage.output_tokens
print(produs)
print(" ", raspuns.content[0].text)
print("Tokeni de ieșire în total:", total_iesire)
Explicația
Acesta este cel mai simplu tipar de aplicație AI folosit în magazine: aceleași reguli pentru toate produsele, date diferite la fiecare apel. Regulile stau în system prompt, o singură dată, iar fiecare cerere conține doar produsul.
Fiecare produs are apelul lui, separat. Dacă ai pune toate produsele într-un singur mesaj, ar trebui apoi să desparți textul primit și ai risca descrieri amestecate sau un produs sărit. Apelurile separate sunt independente: dacă unul eșuează, îl reiei doar pe el.
Regula „nu inventa caracteristici” este importantă: un model care scrie marketing tinde să adauge detalii plauzibile (greutate, garanție) care pot fi false și pot crea probleme cu clienții. Adunarea tokenilor de ieșire îți arată cât costă un lot; la mii de produse, alegi pe baza ei modelul și lungimea textului.
6Ușor Blocat Rezolvat
Repară un apel care trimite temperature și dă eroare
Un coleg a scris în editor un apel care trimite temperature=0.2 ca să obțină răspunsuri mai „serioase”, iar programul se oprește cu eroare.
Scrie două funcții, raspuns_claude(system, mesaj) și raspuns_openai(system, mesaj), care primesc aceleași argumente și returnează textul, ca aplicația să poată schimba furnizorul dintr-o setare.
Compară trei modele pe aceeași întrebare și costul fiecăruia
Trimite aceeași cerință la trei modele Claude și afișează un tabel cu tokenii, costul și primele cuvinte din răspuns, ca să alegi modelul pentru o aplicație de suport.
Continuă un răspuns tăiat de max_tokens fără să pierzi textul
Scrie o funcție genereaza_complet(cerinta, pas=60, max_runde=4) care cere un text lung și, dacă răspunsul a fost tăiat de max_tokens, îi cere modelului să continue exact de unde a rămas, apoi lipește bucățile.
Transformă un prompt vag într-unul clar pentru e-mailuri de ofertă
Rescrie promptul vag din constanta PROMPT (Scrie un e-mail de ofertă pentru clienți.) astfel încât modelul să producă de la prima încercare un e-mail utilizabil, apoi trimite-l.
Adaugă exemple few-shot pentru tonul răspunsurilor de suport
Construiește un system prompt cu două exemple (few-shot) care arată tonul și lungimea dorită pentru răspunsurile unui operator de telefonie, apoi folosește-l pentru o întrebare nouă.
Cere modelului datele unei rezervări într-un obiect JSON, transformă textul în dicționar Python cu json.loads și tratează cazul în care răspunsul nu este JSON valid.
Extrage numele, telefonul și orașul dintr-un mesaj de comandă
Folosește ieșirea structurată cu schemă JSON (output_config) ca să extragi garantat câmpurile nume, telefon și oras din mesajele primite de un magazin.
Validează JSON-ul primit de la model cu un dataclass și reguli proprii
Definește un dataclassProgramare pentru o programare la o clinică veterinară și folosește-l ca să validezi răspunsul JSON primit de la Claude, înainte să-l salvezi.
Clasifică tichetele de suport pe categorie și prioritate
Clasifică tichetele de suport din TICHETE după categorie și prioritate, cu o schemă JSON care permite doar valorile din listă, apoi afișează coada sortată.
Scrie un prompt cu pași numerotați pentru rezumatul unui contract
Scrie un prompt care rezumă contractul de închiriere din fișierul contract.txt în pași clari, ca un angajat dintr-o agenție imobiliară să vadă rapid ce contează.
Scrie o funcție cere_json(mesaj, chei, incercari=3) care cere un obiect JSON fără ieșire structurată și, dacă răspunsul nu se parsează sau lipsesc chei, îi trimite modelului eroarea și cere corectarea.
Testează un prompt de clasificare pe un set de exemple etichetate
Măsoară acuratețea unui prompt care clasifică e-mailurile unei bănci în card, credit, cont sau altele, rulându-l pe cele 8 exemple etichetate de mână din TESTE.
Folosește un LLM ca evaluator pentru răspunsurile de suport
Scrie un evaluator automat (LLM-as-judge) care notează răspunsurile unui chatbot de suport pentru un magazin de electronice pe 3 criterii, cu note de la 1 la 5 și justificare.
Află câți tokeni are un prompt înainte să-l trimiți
Numără tokenii unui prompt cu client.messages.count_tokens înainte de a-l trimite și refuză apelul dacă depășește bugetul de 2.000 de tokeni de intrare (constanta BUGET).
Păstrează doar ultimele N schimburi din istoricul conversației
Scrie funcția taie_istoric(istoric, n) care păstrează doar ultimele n schimburi (o întrebare a clientului cu răspunsul ei) dintr-o conversație, fără să strice regula că primul mesaj trebuie să fie de la user.
Ține istoricul conversației sub un buget de tokeni
Scrie funcția potriveste_in_buget(client, system, istoric, buget) care elimină cele mai vechi schimburi din istoric până când tokenii de intrare (numărați cu count_tokens) ajung cel mult la buget.
Când istoricul unui chatbot de turism depășește 8 mesaje (PRAG), înlocuiește mesajele vechi cu un rezumat scurt făcut de model, păstrând ultimele 4 mesaje (PASTREAZA) neatinse.
Construiește un chatbot de suport cu memorie și limită de context
Scrie o clasă ChatbotSuport pentru un furnizor de internet, care ține istoricul, respectă un buget de tokeni pe cerere și păstrează faptele importante despre client chiar și după ce mesajele vechi sunt tăiate.
Semnalează modelului eroarea unui tool cu is_error
Modifică execuția tool-ului cauta_zbor(cod) al unei agenții de turism astfel încât, când zborul nu există sau serviciul nu răspunde, modelul să primească eroarea marcată cu is_error și să-i explice clientului ce s-a întâmplat.
Implementează bucla completă de tool use pentru un calculator de TVA
Scrie funcția ruleaza(intrebare) care repetă apelurile la model cât timp acesta cere tool-uri, execută tool-ul calculeaza_tva și returnează textul final.
Execută mai multe tool-uri cerute în același răspuns
Tratează corect cazul în care modelul cere mai multe tool-uri în același răspuns (apeluri în paralel), la un asistent de călătorii care are vremea(oras) și curs_valutar(moneda).
Construiește un dispecer de tool-uri cu un dicționar de funcții
Scrie un dispecer reutilizabil executa(bloc) care primește un bloc tool_use, găsește funcția potrivită într-un registru și returnează dicționarul tool_result gata de trimis, inclusiv pentru erori.
Validează argumentele unui tool înainte să-l execuți
Adaugă validare pentru argumentele tool-ului programeaza_test_drive(model, data, ora, telefon) al unui dealer auto, înainte de a scrie ceva în baza de date.
Implementează function calling cu OpenAI Responses API
Scrie bucla de function calling pentru OpenAI Responses API, cu modelul gpt-6-luna, pentru un asistent de cinematograf care are funcția program_filme(data).
Scrie un tool SQL doar în citire pentru un asistent intern
Creează un tool interogheaza_vanzari(sql) pentru un asistent intern de vânzări, care permite modelului să scrie interogări SQL pe o bază SQLite, dar doar în citire și cu rezultate limitate.
Calculează similaritatea cosinus între doi vectori
Scrie funcția cosinus(a, b) în Python pur (doar modulul math) care calculează similaritatea cosinus între doi vectori și folosește-o ca să afli care document e mai apropiat de o întrebare.
Împarte un document în bucăți de lungime fixă cu suprapunere
Scrie funcția imparte(text, marime, suprapunere) care împarte un text în bucăți de cel mult marime cuvinte, fiecare bucată începând cu ultimele suprapunere cuvinte din bucata anterioară.
Găsește documentul cel mai apropiat de întrebarea unui client
Folosește embeddings ca să găsești, dintre cele 4 răspunsuri pregătite de o firmă de curierat (RASPUNSURI), pe cel care se potrivește cel mai bine cu întrebarea clientului (INTREBARE).
Pune contextul găsit în prompt cu instrucțiunea de a nu inventa
Scrie funcția construieste_prompt(intrebare, bucati) care pune bucățile găsite de căutare într-un prompt RAG pentru asistentul unei primării, cu reguli clare împotriva halucinațiilor.
Răspunde din documente și citează sursele cu numărul bucății
Fă ca asistentul unei companii de asigurări să răspundă din bucățile găsite și să indice după fiecare afirmație sursa, în forma [1], [2], apoi verifică în cod că toate citările există.
Adaugă metadate la bucăți și filtrează după departament
Scrie indexul unui asistent intern în care fiecare bucată are metadate (departament, document, actualizat), iar căutarea poate filtra după departament înainte de similaritate.
Salvează embeddings pe disc ca să nu le recalculezi
Scrie funcția embeddings_cu_cache(texte, cale="cache_embeddings.json") care calculează embeddings doar pentru textele noi și le reia pe celelalte dintr-un fișier, ca reindexarea zilnică a unui catalog să nu plătească din nou pentru textele neschimbate.
Construiește un asistent RAG pentru procedurile unui service auto
Construiește un asistent care răspunde mecanicilor unui service auto din manualul intern de proceduri (fișierele .txt din folderul manual), cu tot fluxul RAG într-o singură clasă.
Spune agentului în system prompt când trebuie să se oprească
Scrie system prompt-ul unui agent care pregătește oferte pentru o firmă de amenajări și care, fără reguli de oprire, tot cere informații sau caută la nesfârșit.
Construiește un agent care caută în fișiere și răspunde
Construiește un agent pentru documentația internă a unei firme, cu două tool-uri, listeaza_fisiere() și citeste_fisier(nume), care lucrează doar în folderul docs_firma.
Adaugă unui asistent personal de cumpărături o memorie pe termen lung prin două tool-uri, salveaza_nota(cheie, text) și citeste_note(), care scriu într-un fișier JSON separat pentru fiecare utilizator (memorie/<utilizator>.json).
Scrie partea de protocol a unui server MCP pentru un inventar
Un server MCP (Model Context Protocol) expune tool-uri pe care orice aplicație compatibilă (de exemplu Claude Desktop sau Claude Code) le poate folosi fără cod de integrare scris special.
Calculează costul unei cereri dintr-un preț dat pe milion de tokeni
Scrie funcția cost_cerere(tokeni_in, tokeni_out, pret_in, pret_out) care calculează costul unei cereri în dolari, știind prețurile pe milion de tokeni, și folosește-o pentru o cerere de rezumat.
Implementează exponential backoff cu jitter pentru erorile 429
Scrie funcția cu_reincercare(functie, max_incercari=5, baza=1.0, maxim=30.0) care reîncearcă un apel la API când primește 429, 5xx (de exemplu 529) sau o eroare de conexiune, cu pauze care cresc exponențial și au o parte aleatoare (jitter):
Analizează 500 de recenzii ale unui hotel prin Message Batches API, care procesează cererile asincron, cu o reducere de 50% față de apelurile obișnuite.
Construiește o suită de teste de regresie pentru prompturi
Construiește o suită de evaluare automată (evals) pentru asistentul unei agenții de turism, pe care o rulezi înainte de orice schimbare de prompt sau de model și care eșuează dacă rata de trecere scade sub prag.
Comută automat pe alt furnizor când API-ul principal e suprasolicitat
Scrie funcția genereaza(system, mesaj, acum) pentru chatbotul unui magazin online, care folosește Claude ca furnizor principal și trece automat pe OpenAI (gpt-6-luna, prin Responses API) când Claude e indisponibil, apoi revine la Claude după o pauză.
Maschează e-mailurile și telefoanele înainte de a le trimite la model
Scrie funcția mascheaza(text) care înlocuiește adresele de e-mail cu [EMAIL] și numerele de telefon mobil românești cu [TELEFON], ca mesajele clienților să fie trimise la model fără aceste date personale.
Limitează tool-urile disponibile după rolul utilizatorului
Scrie funcția tools_pentru(rol) pentru asistentul intern al unei clinici, care returnează doar tool-urile la care are acces rolul utilizatorului (lista trimisă la API), și dispecerul executa(rol, nume_tool, argumente), care verifică din nou permisiunea și aruncă AccesInterzis pentru orice tool nepermis.
Anonimizează CNP-urile și IBAN-urile dintr-un tichet de suport
Scrie funcția anonimizeaza(text) care înlocuiește CNP-urile și IBAN-urile românești dintr-un tichet cu etichete numerotate ([CNP_1], [IBAN_1] etc.) și returnează și dicționarul de corespondență (etichetă -> valoare), ca valorile reale să poată fi puse înapoi după răspunsul modelului.
Protejează un agent care citește pagini web de instrucțiuni ascunse
Implementează protecțiile unui agent de cercetare a prețurilor pentru un magazin, care citește pagini ale concurenței cu tool-ul citeste_pagina(url) și salvează rezultate cu salveaza_pret(produs, pret, sursa).
Gestionează datele personale ale unui asistent HR conform GDPR
Implementează gestionarea datelor personale pentru conversațiile unui asistent intern de HR, care primește întrebări de la angajați despre salariu, concedii și beneficii.
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Exercițiile de aici sunt gândite ca la job: date concrete, cerințe clare și soluții pe care le poți explica la un interviu de Aplicații AI cu LLM.
Învață Aplicații AI cu LLM de la zero, cu exerciții la fiecare lecție
Curs Aplicații AI cu Claude și OpenAI: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 8 lecții sunt gratuite.