Com crear un agent d'IA

Com crear un agent d'IA

Resposta curta: Per construir un agent d'IA que funcioni a la pràctica, tracteu-lo com un bucle controlat: preneu les dades, decidiu la següent acció, crideu una eina amb un abast reduït, observeu el resultat i repetiu-ho fins que es superi una comprovació clara de "fet". Es guanya el seu lloc quan la tasca és de diversos passos i està basada en eines; si una sola indicació la resol, ometeu l'agent. Afegiu esquemes d'eines estrictes, límits de passos, registre i un validador/crític perquè quan les eines fallen o les entrades siguin ambigües, l'agent escali en lloc de fer un bucle.

Conclusions clau:

Bucle de controlador : Implementa entrada→actuar→observar repetició amb condicions d'aturada explícites i passos màxims.

Disseny d'eines : Mantingueu les eines reduïdes, tipificades, amb permisos i validades per evitar el caos de "fes_qualsevol cosa".

Higiene de memòria : utilitzeu un estat compacte a curt termini més una recuperació a llarg termini; eviteu abocar transcripcions completes.

Resistència a l'ús indegut : afegiu llistes de permesos, límits de velocitat, idempotència i "execució a prova" per a accions arriscades.

Testabilitat : Mantenir un conjunt d'escenaris (errors, ambigüitats, injeccions) i tornar-lo a executar amb cada canvi.

Com crear un agent d'IA? Infografia
Articles que potser t'agradaria llegir després d'aquest:

🔗 Com mesurar el rendiment de la IA
Aprèn mètriques pràctiques per comparar la velocitat, la precisió i la fiabilitat.

🔗 Com parlar amb la IA
Utilitzeu indicacions, context i seguiments per obtenir millors respostes.

🔗 Com avaluar models d'IA
Compara models mitjançant proves, rúbriques i resultats de tasques del món real.

🔗 Com optimitzar els models d'IA
Millora la qualitat i el cost amb l'afinació, la poda i la supervisió.

1) Què és un agent d'IA, en termes normals 🧠

Un agent d'IA és un bucle. Documentació d'"Agents" de LangChain

Això és tot. Un bucle amb un cervell al mig.

Entrada → pensar → actuar → observar → repetir . Reaccionar al paper (raonar + actuar)

On:

  • L'entrada és una sol·licitud d'usuari o un esdeveniment (nou correu electrònic, tiquet d'assistència, ping de sensor).

  • Pensar és un model de llenguatge que raonamenta sobre el següent pas.

  • Actuar és cridar una eina (cercar documents interns, executar codi, crear un tiquet, esborrar una resposta). Guia de crida de funcions OpenAI

  • Observe està llegint la sortida de l'eina.

  • La repetició és la part que fa que sembli "agent" en lloc de "xerraire". Documentació de "Agents" de LangChain.

Alguns agents són bàsicament macros intel·ligents. D'altres actuen més com un operador júnior que pot fer malabarismes amb tasques i recuperar-se d'errors. Tots dos compten.

A més, no necessites autonomia total. De fet... probablement no la vols 🙃

2) Quan hauries de crear un agent (i quan no) 🚦

Crea un agent quan:

  • El treball consta de diverses etapes i canvia en funció del que passi a mig camí.

  • La feina requereix l'ús d'eines (bases de dades, CRM, execució de codi, generació de fitxers, navegadors, API internes). Documentació de "Eines" de LangChain.

  • Voleu resultats repetibles amb barreres de seguretat, no només respostes puntuals.

  • Podeu definir "fet" de manera que un ordinador ho pugui comprovar, fins i tot de manera imprecisa.

No creeu un agent quan:

  • Una simple indicació + resposta ho soluciona (no ho facis massa, t'odiaràs més tard).

  • Necessiteu un determinisme perfecte (els agents poden ser consistents, però no robòtics).

  • No tens cap eina ni dades per connectar-te; aleshores, principalment, només són vibracions.

Siguem francs: la meitat dels "projectes d'agents d'IA" podrien ser un flux de treball amb unes quantes regles de ramificació. Però, ei, de vegades l'ambient també importa 🤷♂️

3) Què fa que una bona versió d'un agent d'IA sigui ✅

Aquí teniu la secció "Què fa que una versió sigui bona de" que heu demanat, excepte que seré una mica directe:

Una bona versió d'un agent d'IA no la que pensa més. És la que:

Si el teu agent no es pot posar a prova, bàsicament és una màquina escurabutxaques molt segura. Diversió a les festes, terrorífica en la producció 😬

4) Els components bàsics d'un agent (l'"anatomia" 🧩)

La majoria d'agents sòlids tenen aquestes peces:

A) El bucle de controlador 🔁

Aquest és l'orquestrador:

B) Eines (també conegudes com a capacitats) 🧰

Les eines són el que fa que un agent sigui eficaç: documents de "Eines" de LangChain

  • consultes de base de dades

  • enviament de correus electrònics

  • extracció de fitxers

  • codi en execució

  • crida a les API internes

  • escriure en fulls de càlcul o CRM

C) Memòria 🗃️

Importen dos tipus:

  • memòria a curt termini : el context de la cursa actual, els passos recents, el pla actual

  • memòria a llarg termini : preferències de l'usuari, context del projecte, coneixement recuperat (sovint mitjançant incrustacions + un magatzem vectorial) article RAG

D) Política de planificació i decisió 🧭

Fins i tot si no ho anomeneu "planificació", necessiteu un mètode:

E) Baranes de protecció i avaluació 🧯

Sí, és més enginyeria que incitació. Que és... més o menys la qüestió.

5) Taula comparativa: maneres populars de crear un agent 🧾

A continuació es mostra una "Taula comparativa" realista, amb algunes peculiaritats, perquè els equips reals són peculiars 😄

Eina / Marc de treball Públic Preu Per què funciona Notes (un petit caos)
LangChain constructors a qui els agraden els components d'estil Lego més o menys gratuït + infra gran ecosistema per a eines, memòria, cadenes pots aconseguir espaguetis ràpidament si no anomenas les coses clarament
Índex de llames Equips amb RAG pesat més o menys gratuït + infra patrons de recuperació forts, indexació, connectors genial quan el teu agent és bàsicament "cerca + acció"... cosa que és habitual
Enfocament d'estil d'assistents d'OpenAI equips que volen una configuració més ràpida basat en l'ús patrons de crida d'eines integrats i estat d'execució menys flexible en alguns racons, però net per a moltes aplicacions API d'execució d'OpenAI Crida a la funció d'assistents d'OpenAI
Nucli semàntic desenvolupadors que volen una orquestració estructurada lliure abstracció ordenada per a habilitats/funcions sembla "empresa ordenada" - de vegades això és un elogi 😉
AutoGen experimentadors multiagent lliure patrons de col·laboració entre agents pot parlar massa; establir normes estrictes d'acomiadament
CrewAI aficionats als "equips d'agents" lliure Els rols + les tasques + les transferències són fàcils d'expressar funciona millor quan les tasques són nítides, no pas toves
Paller cerca + pipelines persones lliure canonades sòlides, recuperació, components menys “teatre d'agents”, més “fàbrica pràctica”
Enrotlla el teu propi (bucle personalitzat) maniàtics del control (afectuosos) el teu temps màgia mínima, claredat màxima normalment és el millor a llarg termini... fins que ho reinventes tot 😅

No hi ha un únic guanyador. La millor elecció depèn de si la tasca principal del vostre agent és la recuperació , l'execució d'eines , la coordinació multiagent o l'automatització del flux de treball .

6) Com construir un agent d'IA pas a pas (la recepta real) 🍳🤖

Aquesta és la part que la majoria de la gent es salta i després es pregunta per què l'agent es comporta com un ós rentador en un rebost.

Pas 1: Defineix la feina en una frase 🎯

Exemples:

  • "Redacta una resposta del client utilitzant la política i el context del tiquet i, a continuació, sol·licita la seva aprovació."

  • "Investiga un informe d'error, reprodueix-lo i proposa una solució."

  • "Converteix les notes de reunió imperfectes en tasques, responsables i terminis."

Si no ho pots definir de manera senzilla, el teu agent tampoc. Vull dir que sí que ho pot fer, però improvisarà, i la improvisació és on moren els pressupostos.

Pas 2: Decideix el nivell d'autonomia (baix, mitjà, picant) 🌶️

  • Baixa autonomia : suggereix passos, els clics humans "aproven"

  • Medi : executa eines, esborranys de resultats, augmenta la incertesa

  • Alt : s'executa de punta a punta, només fa ping als humans en cas d'excepcions

Comença més baix del que vulguis. Sempre pots pujar-lo més tard.

Pas 3: Trieu la vostra estratègia de model 🧠

Normalment tries:

  • un model fort per a tot (simple)

  • un model fort + un model més petit per a passos econòmics (classificació, encaminament)

  • models especialitzats (visió, codi, parla) si cal

També decideix:

  • fitxes màximes

  • temperatura

  • si permeteu traces de raonament llargues internament (podeu, però no exposeu la cadena de pensament en brut als usuaris finals)

Pas 4: Definir eines amb esquemes estrictes 🔩

Les eines haurien de ser:

En lloc d'una eina anomenada do_anything(input: string) , feu:

  • cerca_kb(consulta: cadena) -> resultats[]

  • create_ticket(title: string, body: string, priority: enum) -> ticket_id

  • send_email(to: string, subject: string, body: string) -> status Guia de crida de funcions OpenAI

Si li doneu a l'agent una motoserra, no us sorprengueu quan retalli una bardissa traient també la tanca.

Pas 5: Construeix el bucle del controlador 🔁

Bucle mínim:

  1. Comença amb l'objectiu + context inicial

  2. Pregunta al model: "Propera acció?"

  3. Si es crida l'eina, executa l'eina

  4. Adjunta l'observació

  5. Comprovar la condició d'aturada

  6. Repetir (amb el màxim de passos) la documentació d'"Agents" de LangChain

Afegeix:

Pas 6: Afegeix memòria amb cura 🗃️

Curt termini: mantenir un "resum d'estat" compacte actualitzat a cada pas. LangChain "Visió general de la memòria".
Llarg termini: emmagatzemar dades duradores (preferències de l'usuari, regles organitzatives, documents estables).

Regla general:

  • si canvia sovint, mantingueu-ho a curt termini

  • si és estable, emmagatzemar a llarg termini

  • si és sensible, emmagatzemar mínimament (o gens)

Pas 7: Afegiu la validació i un aprovat de "crític" 🧪

Un patró pràctic i econòmic:

  • l'agent genera un resultat

  • El validador comprova l'estructura i les restriccions

  • Revisions opcionals del model crític per passos que falten o infraccions de polítiques NIST AI RMF 1.0

No és perfecte, però capta una quantitat sorprenent de ximpleries.

Pas 8: Registra tot allò que et penediràs de no haver registrat 📜

Registre:

Futur, t'ho agrairàs. Present, ho oblidaràs. Això és simplement la vida 😵💫

7) Trucades d'eines que no et trenquen l'ànima 🧰😵

La crida d'eines és on "Com crear un agent d'IA" esdevé enginyeria de programari real.

Feu que les eines siguin fiables (la fiabilitat és bona)

Les eines fiables són:

Afegiu baranes a la capa d'eines, no només indicacions

Els suggeriments són suggeriments educats. La validació d'eines és una porta tancada. Sortides estructurades d'OpenAI

Fes:

  • llistes permeses (quines eines poden executar)

  • validació d'entrada

  • límits de velocitat Guia de límits de velocitat d'OpenAI

  • comprovacions de permisos per usuari/organització

  • "mode d'execució en sec" per a accions arriscades

Disseny per a falla parcial

Les eines fallen. Les xarxes trontollen. L'autenticació caduca. Un agent ha de:

Un truc discretament eficaç: retornar errors estructurats com ara:

  • tipus: error_d'autenticació

  • tipus: no_trobat

  • tipus: rate_limited
    Perquè el model pugui respondre intel·ligentment en comptes d'entrar en pànic.

8) Records que t'ajuden en comptes de perseguir-te 👻🗂️

La memòria és poderosa, però també es pot convertir en un calaix de trastos.

Memòria a curt termini: mantenir-la compacta

Ús:

  • últims N passos

  • un resum en execució (actualitzat a cada bucle)

  • pla actual

  • restriccions actuals (pressupost, temps, polítiques)

Si ho poses tot en context, obtens:

  • cost més elevat

  • latència més lenta

  • més confusió (sí, fins i tot llavors)

Memòria a llarg termini: recuperació en lloc de "farciment"

La major part de la "memòria a llarg termini" s'assembla més a:

  • incrustacions

  • botiga de vectors

  • generació augmentada de recuperació (RAG) paper RAG

L'agent no memoritza. Recupera els fragments més rellevants en temps d'execució. LlamaIndex "Introducció a RAG"

Regles pràctiques de memòria

  • Emmagatzemar les "preferències" com a fets explícits: "A l'usuari li agraden els resums amb vinyetes i odia els emojis" (lol, aquí no 😄)

  • Emmagatzemar les "decisions" amb marques de temps o versions (en cas contrari, s'acumulen contradiccions)

  • No guardeu mai secrets si no és realment necessari

I aquí teniu la meva metàfora imperfecta: la memòria és com una nevera. Si mai la netegeu, finalment el vostre entrepà tindrà gust de ceba i penediment.

9) Patrons de planificació (de simples a sofisticats) 🧭✨

La planificació és només una descomposició controlada. No ho facis místic.

Patró A: Planificador de llistes de control ✅

  • El model genera una llista de passos

  • S'executa pas a pas

  • Actualitza l'estat de la llista de comprovació

Ideal per a la incorporació. Simple i comprovable.

Patró B: Bucle ReAct (raó + acte) 🧠→🧰

  • el model decideix la propera crida d'eines

  • observa la sortida

  • repeteix el paper ReAct

Aquesta és la sensació clàssica d'un agent.

Patró C: Supervisor-treballador 👥

Això és valuós quan les tasques són paral·lelizables o quan voleu diferents "rols" com ara:

  • investigador

  • codificador

  • editor

  • Verificador de control de qualitat

Patró D: Planificar i després executar amb replanificació 🔄

  • crear un pla

  • executar

  • si els resultats de l'eina canvien la realitat, replanteu-ho

Això impedeix que l'agent segueixi tossudament un mal pla. Els humans també ho fan, tret que estiguin cansats, i en aquest cas també segueixen mals plans.

10) Seguretat, fiabilitat i no ser acomiadat 🔐😅

Si el vostre agent pot prendre mesures, necessiteu un disseny de seguretat. No és "bo de tenir". Cal. NIST AI RMF 1.0

Límits estrictes

  • passos màxims per cursa

  • màximes trucades d'eines per minut

  • despesa màxima per sessió (pressupost de tokens)

  • eines restringides darrere de l'aprovació

Tractament de dades

  • Redactar les entrades sensibles abans de registrar

  • entorns separats (desenvolupament vs producció)

  • permisos d'eina amb privilegis mínims

Restriccions de comportament

  • obligar l'agent a citar fragments de proves internes (no enllaços externs, només referències internes)

  • requereixen indicadors d'incertesa quan la confiança és baixa

  • requereix "fer una pregunta aclaratòria" si les entrades són ambigües

Un agent fiable no és el que té més confiança. És el que sap quan està endevinant... i ho diu.

11) Proves i avaluació (la part que tothom evita) 🧪📏

No pots millorar allò que no pots mesurar. Sí, aquesta frase és cursi, però és fastidiosament certa.

Crear un conjunt d'escenaris

Crea entre 30 i 100 casos de prova:

Resultats de puntuació

Utilitzeu mètriques com ara:

  • taxa d'èxit de les tasques

  • temps de finalització

  • taxa de recuperació d'errors d'eina

  • taxa d'al·lucinacions (afirmacions sense proves)

  • taxa d'aprovació humana (si està en mode supervisat)

Proves de regressió per a indicacions i eines

Cada cop que canvieu:

  • esquema d'eines

  • instruccions del sistema

  • lògica de recuperació

  • format de memòria
    Torneu a executar el paquet.

Els agents són bèsties sensibles. Com les plantes d'interior, però més cares.

12) Patrons de desplegament que no et fonen el pressupost 💸🔥

Comença amb un sol servei

Afegiu controls de costos aviat

  • emmagatzemar els resultats de recuperació a la memòria cau

  • comprimint l'estat de la conversa amb resums

  • utilitzant models més petits per a l'encaminament i l'extracció

  • limitant el "mode de pensament profund" als passos més difícils

Elecció d'arquitectura comuna

  • controlador sense estat + magatzem d'estat extern (DB/redis)

  • Les crides a les eines són idempotents sempre que sigui possible. Les "sol·licituds idempotents" de Stripe

  • cua per a tasques llargues (per tal que no mantingueu una sol·licitud web oberta per sempre)

A més: construeix un "interruptor d'aturada". No el necessitaràs fins que realment, realment el necessitis 😬

13) Notes finals: la versió curta sobre com crear un agent d'IA 🎁🤖

Si no recordes res més, recorda això:

Un agent no és màgia. És un sistema que pren bones decisions prou sovint com per ser valuós... i admet la derrota abans que causi danys. En certa manera, tranquil·lament reconfortant 😌

I sí, si ho construeixes bé, és com contractar un petit becari digital que mai dorm, de vegades entra en pànic i li encanta la paperassa. Així doncs, bàsicament un becari.

Preguntes freqüents

Què és un agent d'IA, en termes senzills?

Un agent d'IA és bàsicament un bucle que es repeteix: pren informació, decideix el següent pas, utilitza una eina, llegeix el resultat i repeteix fins que s'hagi acabat. La part "agència" prové d'actuar i observar, no només de xatejar. Molts agents són simplement automatització intel·ligent amb accés a eines, mentre que d'altres es comporten més com un operador júnior que es pot recuperar d'errors.

Quan hauria de crear un agent d'IA en comptes d'utilitzar només un indicador?

Crea un agent quan la feina sigui de diversos passos, canviï en funció de resultats intermedis i necessiti un ús d'eines fiable (API, bases de dades, ticketing, execució de codi). Els agents també són útils quan es volen resultats repetibles amb barreres de seguretat i una manera de comprovar si està "fet". Si una resposta ràpida simple funciona, un agent sol ser una sobrecàrrega innecessària i modes d'error addicionals.

Com puc crear un agent d'IA que no es quedi encallat en bucles?

Utilitzeu condicions d'aturada estricta: passos màxims, crides d'eina màximes i comprovacions de finalització neta. Afegiu esquemes d'eines estructurats, temps d'espera i reintents que no es tornin a intentar per sempre. Registreu les decisions i les sortides de les eines per poder veure on es descarrila. Una vàlvula de seguretat habitual és l'escalada: si l'agent no està segur o repeteix errors, hauria de demanar ajuda en lloc d'improvisar.

Quina és l'arquitectura mínima per a Com construir un agent d'IA?

Com a mínim necessiteu un bucle de controlador que alimenti el model amb un objectiu i un context, demani la següent acció, executi una eina si se li sol·licita, afegeixi l'observació i repeteixi. També necessiteu eines amb formes d'entrada/sortida estrictes i una comprovació de "fet". Fins i tot un bucle de creació pròpia pot funcionar bé si manteniu l'estat net i apliqueu límits de pas.

Com he de dissenyar la crida d'eines perquè sigui fiable en producció?

Mantingueu les eines reduïdes, amb tipus, permisos i validades; eviteu una eina genèrica de tipus "fes-hi qualsevol cosa". Preferiu esquemes estrictes (com ara sortides estructurades/crides de funcions) perquè l'agent no pugui imposar manualment les entrades. Afegiu llistes de permesos, límits de velocitat i comprovacions de permisos d'usuari/organització a la capa d'eines. Dissenyeu les eines perquè es puguin tornar a executar de manera segura sempre que sigui possible, utilitzant patrons d'idempotència.

Quina és la millor manera d'afegir memòria sense empitjorar l'agent?

Tracteu la memòria com dues parts: estat d'execució a curt termini (passos recents, pla actual, restriccions) i recuperació a llarg termini (preferències, regles estables, documentació rellevant). Mantingueu un termini compacte amb resums en curs, no transcripcions completes. Per a la memòria a llarg termini, la recuperació (incrustacions + emmagatzematge vectorial/patrons RAG) sol ser millor que "ficar-ho tot en context i confondre el model.

Quin patró de planificació hauria d'utilitzar: llista de verificació, ReAct o supervisor-treballador?

Un planificador de llistes de control és fantàstic quan les tasques són predictibles i voleu alguna cosa fàcil de provar. Els bucles d'estil ReAct destaquen quan els resultats de les eines canvien el que feu a continuació. Els patrons supervisor-treballador (com la separació de rols d'estil AutoGen) ajuden quan les tasques es poden paral·lelitzar o beneficiar-se de rols diferents (investigador, codificador, control de qualitat). Planificar i després executar amb replanificació és un punt intermedi pràctic per evitar plans dolents tossuts.

Com puc fer que un agent sigui segur si pot dur a terme accions reals?

Utilitzeu permisos de privilegis mínims i restringiu les eines de risc darrere dels modes d'aprovació o "execució a prova". Afegiu pressupostos i límits: passos màxims, despesa màxima i límits de crida d'eines per minut. Redacteu les dades sensibles abans de registrar-les i separeu els entorns de desenvolupament dels de producció. Exigiu indicadors d'incertesa o preguntes aclaridores quan les entrades siguin ambigües, en lloc de deixar que la confiança substitueixi l'evidència.

Com puc provar i avaluar un agent d'IA perquè millori amb el temps?

Crea un conjunt d'escenaris amb camins feliços, casos límit, errors d'eines, sol·licituds ambigües i intents d'injecció de prompts (estil OWASP). Puntua resultats com l'èxit de la tasca, el temps de finalització, la recuperació d'errors d'eina i les reclamacions sense proves. Cada vegada que canviïs els esquemes, els prompts, la recuperació o el format de memòria de les eines, torna a executar el conjunt. Si no el pots provar, no el pots enviar de manera fiable.

Com puc implementar un agent sense augmentar la latència ni els costos?

Un patró comú és un controlador sense estat amb un magatzem d'estat extern (base de dades/Redis), serveis d'eines al darrere i un registre/monitorització forts (sovint OpenTelemetry). Controleu els costos amb l'emmagatzematge en memòria cau de recuperació, resums d'estat compactes, models més petits per a l'encaminament/extracció i limitació del "pensament profund" als passos més difícils. Utilitzeu cues per a tasques llargues per no mantenir obertes les sol·licituds web. Incloeu sempre un interruptor de desactivació.

Referències

  1. Institut Nacional d'Estàndards i Tecnologia (NIST) - NIST AI RMF 1.0 (fiabilitat i transparència) - nvlpubs.nist.gov

  2. OpenAI - Sortides estructurades - platform.openai.com

  3. OpenAI - Guia de crida de funcions - platform.openai.com

  4. OpenAI - Guia de límits de velocitat - platform.openai.com

  5. OpenAI : executa l'API - platform.openai.com

  6. OpenAI - Crida de funcions d'assistents - platform.openai.com

  7. LangChain - Documentació dels agents (JavaScript) - docs.langchain.com

  8. LangChain - Documentació d'eines (Python) - docs.langchain.com

  9. LangChain - Visió general de la memòria - docs.langchain.com

  10. arXiv - Article ReAct (raó + acció) - arxiv.org

  11. arXiv - Article RAG - arxiv.org

  12. Biblioteca de constructors d'Amazon Web Services (AWS) : temps d'espera, reintents i retrocés amb jitter - aws.amazon.com

  13. OpenTelemetry - Introducció a l'observabilitat - opentelemetry.io

  14. Stripe - Sol·licituds idempotents - docs.stripe.com

  15. Google Cloud - Estratègia de reintent (backoff + jitter) - docs.cloud.google.com

  16. OWASP - Els 10 millors per a aplicacions de models de llenguatge grans - owasp.org

  17. OWASP - Injecció ràpida LLM01 - genai.owasp.org

  18. LlamaIndex - Introducció a RAG - developers.llamaindex.ai

  19. Microsoft - Nucli semàntic - learn.microsoft.com

  20. Microsoft AutoGen - Marc de treball multiagent (documentació) - microsoft.github.io

  21. CrewAI - Conceptes d'agents - docs.crewai.com

  22. Haystack (deepset) - Documentació de gossos recuperadors - docs.haystack.deepset.ai

Troba la darrera versió d'IA a la botiga oficial d'assistents d'IA

Sobre nosaltres

Torna al bloc