<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Albert Gil López on Medium]]></title>
        <description><![CDATA[Stories by Albert Gil López on Medium]]></description>
        <link>https://medium.com/@jddam?source=rss-3723dc84302b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*NGrTWg_ruO-u00-7rWX71w.jpeg</url>
            <title>Stories by Albert Gil López on Medium</title>
            <link>https://medium.com/@jddam?source=rss-3723dc84302b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 12:00:40 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jddam/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Cómo hacer que un LLM diminuto funcione bien: seis palancas medidas en mi portátil (sin GPU)]]></title>
            <link>https://medium.com/@jddam/c%C3%B3mo-hacer-que-un-llm-diminuto-funcione-bien-seis-palancas-medidas-en-mi-port%C3%A1til-sin-gpu-ba90bdc06a2f?source=rss-3723dc84302b------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba90bdc06a2f</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[edge-computing]]></category>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Albert Gil López]]></dc:creator>
            <pubDate>Thu, 02 Jul 2026 10:52:08 GMT</pubDate>
            <atom:updated>2026-07-02T10:52:08.547Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9RmrTCtrjqoB8O4adJCHxQ.png" /></figure><p>Todo el mundo repite lo mismo: para que un modelo de lenguaje funcione, necesitas escala. Más parámetros, más datos, más GPUs. Y es verdad a lo grande. Pero me quedé con una pregunta: ¿qué puede hacer <em>bien</em> un modelo muy pequeño, de menos de un millón de parámetros, entrenado en la CPU de un portátil normal?</p><p>Así que me pasé unas cuantas horas construyendo un LLM desde cero (un <a href="https://github.com/karpathy/nanoGPT">nanoGPT</a> con la aritmética de <a href="https://github.com/microsoft/BitNet">BitNet</a>, el modelo 1-bit de Microsoft) y probando, una por una, las palancas que la gente da por buenas. Sin GPU, en un i5 de portátil. La conclusión: <strong>la mayoría de las optimizaciones “obvias” que predije fallaron al medirlas, y las que funcionaron no eran las que esperaba.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BEagK8YyEDhnjHUXT5BF2Q.png" /><figcaption>Las seis palancas para exprimir un modelo diminuto, todas medidas en un portátil sin GPU.</figcaption></figure><h3>Background</h3><p>El modelo es un Transformer de juguete: <strong>unos 800.000 parámetros</strong> (el GPT-2 más pequeño tiene 124 millones; GPT-4, cientos de miles de millones). Lo entrené con caracteres de texto, primero sobre Shakespeare, y genera texto prediciendo el siguiente carácter, igual que los grandes pero a escala muy pequeña.</p><p>La pregunta de diseño no es “cómo lo hago más listo”. Es al revés: <strong>cómo reduzco el problema hasta que quepa en 800.000 parámetros</strong>. Un modelo así no puede ser una enciclopedia, pero sí un buen procesador. La estrategia es sacar fuera todo lo que no necesita vivir dentro: el conocimiento, la diversidad, incluso parte del razonamiento.</p><p>Un ejemplo de lo que permite esta filosofía: entrenar el modelo con pesos ternarios (solo -1, 0, +1) cuesta apenas un 5% de calidad pero comprime 16 veces frente a la precisión normal. Cuantizar <em>después</em> de entrenar, en cambio, lo rompe. El <em>cuándo</em> importa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gD4Iiyub-rJe12xwIYS6Rg.png" /><figcaption>Cuantización 1-bit: entrenar en ternario cuesta un +5% de calidad y comprime 16 veces.</figcaption></figure><h3>Key concepts</h3><p>Si tienes TOC como yo y tu cerebro necesita entender antes los conceptos que hay por debajo de los LLMs, estos son los términos que salen en el resto del artículo, explicados. Si ya te suenan, sáltatelos.</p><p><em>Cómo el texto se vuelve números:</em></p><ul><li><strong>Token:</strong> un trozo de texto (una palabra, un trozo de palabra o un carácter) que el modelo trata como unidad. El modelo no ve letras, ve números.</li><li><strong>Tokenizador:</strong> el que parte el texto en tokens y les asigna un número (un ID).</li><li><strong>BPE (Byte-Pair Encoding):</strong> el tokenizador que usan GPT, Llama y compañía. Aprende a fusionar los pares de caracteres más frecuentes, así las palabras comunes son un solo token y las raras se parten en trozos. Nunca falla ante una palabra nueva.</li><li><strong>Embedding:</strong> el vector de números (una lista larga) que representa a cada token por dentro.</li><li><strong>Parámetros (o pesos):</strong> los números que el modelo aprende y ajusta durante el entrenamiento. “800.000 parámetros” son 800.000 de esos números. GPT-4 tiene cientos de miles de millones.</li></ul><p><em>La arquitectura:</em></p><ul><li><strong>Transformer:</strong> la arquitectura detrás de casi todos los LLMs (2017, <a href="https://arxiv.org/abs/1706.03762">“Attention is All You Need”</a>). Apila bloques que combinan atención y una red de proceso.</li><li><strong>Atención (self-attention):</strong> el mecanismo por el que cada token “mira” a los demás y decide cuáles son relevantes. Es lo que conecta “el gato… él” y entiende que “él” es el gato.</li><li><strong>Predecir el siguiente token:</strong> la única tarea de un LLM base. Todo lo demás (chatear, razonar, programar) emerge de hacer esto muy bien a gran escala.</li><li><strong>Inferencia:</strong> usar el modelo ya entrenado para generar. Entrenar es aprender; inferir es responder.</li></ul><p><em>Cómo se entrena y se especializa:</em></p><ul><li><strong>Pre-training:</strong> entrenar desde cero prediciendo el siguiente token sobre cantidades enormes de texto. Aquí se aprende el lenguaje. Es lo caro.</li><li><strong>Fine-tuning:</strong> coger un modelo ya entrenado y ajustarlo un poco con datos específicos para especializarlo. Barato en comparación.</li><li><strong>SFT (instruction tuning):</strong> el fine-tuning que convierte un modelo que “completa texto” en uno que “responde”, mostrándole miles de ejemplos de pregunta y respuesta. Es lo que hace que ChatGPT chatee.</li><li><strong>RLHF:</strong> ajustar el modelo con preferencias humanas (qué respuesta es mejor) para que sea útil y no diga barbaridades. La última capa del “tono ChatGPT”.</li><li><strong>LoRA:</strong> una forma barata de fine-tuning (<a href="https://arxiv.org/abs/2106.09685">Hu et al., 2021</a>): congelas el modelo y le añades unas matrices pequeñas entrenables, en vez de reajustar los miles de millones de pesos.</li><li><strong>Destilación:</strong> un modelo grande (profesor) enseña a uno pequeño (alumno) a imitar sus salidas. Funciona cuando el profesor sabe mucho más.</li><li><strong>Loss (cross-entropy):</strong> el número que mide cuánto se equivoca el modelo. Entrenar es bajarlo.</li></ul><p><em>Cómo se hace pequeño y rápido:</em></p><ul><li><strong>Cuantización:</strong> reducir la precisión de los pesos (de 32 bits a 8, 4, o menos) para que ocupen y corran menos. Es redondear a una rejilla más gruesa.</li><li><strong>BitNet / ternario / 1-bit:</strong> cuantización al extremo, donde cada peso solo vale -1, 0 o +1 (<a href="https://arxiv.org/abs/2402.17764">The Era of 1-bit LLMs</a>, Microsoft). Tres valores son log2(3) = 1,58 bits. El truco: multiplicar por -1, 0 o +1 son restas, sumas y saltos, no multiplicaciones. La implementación para correrlos en CPU es <a href="https://github.com/microsoft/BitNet">bitnet.cpp</a>.</li><li><strong>QAT (Quantization-Aware Training):</strong> entrenar el modelo ya con la cuantización puesta, para que aprenda a vivir con la restricción. Es la diferencia entre que el 1-bit funcione o se rompa.</li><li><strong>STE (Straight-Through Estimator):</strong> el truco matemático que permite entrenar a través del redondeo (que no es derivable): usa el valor cuantizado al ir hacia delante y deja pasar el gradiente intacto al volver.</li><li><strong>Kernels, SIMD, AVX:</strong> el nivel más bajo. Un kernel es la rutina que hace las multiplicaciones de matrices; SIMD (con AVX en Intel) es la instrucción que opera sobre muchos números a la vez. Ahí es donde el ternario se convierte en velocidad real.</li></ul><p><em>Cómo se usa de verdad:</em></p><ul><li><strong>RAG (Retrieval-Augmented Generation):</strong> en vez de que el modelo memorice datos, los recupera de una base externa y responde leyéndolos (<a href="https://arxiv.org/abs/2005.11401">Lewis et al., 2020</a>). Actualizable y sin inventar, si el modelo sabe leer el contexto.</li><li><strong>Tool use / agente:</strong> el modelo genera el texto de una “llamada a herramienta” (buscar, calcular), pero no la ejecuta él. Un programa externo la ejecuta y le devuelve el resultado. La inteligencia agéntica es modelo más orquestador, no solo modelo.</li><li><strong>Chain-of-thought:</strong> dejar que el modelo escriba pasos de razonamiento antes de la respuesta. Pensar en voz alta mejora el resultado.</li><li><strong>Test-time compute:</strong> gastar más cómputo en el momento de responder (generar varias respuestas y elegir la buena) en vez de agrandar el modelo. Es lo que hacen modelos como o1.</li></ul><h3>Hands-on</h3><p><strong>1. Los datos importan más que los parámetros.</strong> Con Shakespeare, mi modelo generaba basura casi coherente: <em>“Thy late, vice heart out to keem the sovereign”</em>. Palabras inventadas. Cambié el dataset por <a href="https://arxiv.org/abs/2305.07759">TinyStories</a> (cuentos con vocabulario de niño de cuatro años) sin tocar el modelo, y el mismo tamaño generó: <em>“Once upon a time, there was a little boy named Tim. Timmy loved to play”</em>. Gramática correcta, narrativa, diálogo. El cuello de botella no era el tamaño del modelo, era la <strong>diversidad del mundo</strong> que le pedía aprender. Lo confirmé con un control: recortando TinyStories al mismo tamaño que Shakespeare, la coherencia se mantuvo. Era la simplicidad, no la cantidad.</p><p><strong>2. La profundidad se puede comprar sin parámetros, pero solo a veces.</strong> Apliqué el mismo bloque del Transformer varias veces en bucle (los “looped transformers” de moda en 2026). En una tarea de razonamiento encadenado (seguir una cadena de saltos), el modelo con profundidad efectiva 8 pasó del <strong>55% al 90%</strong> de acierto frente al de profundidad 2, con <strong>los mismos parámetros</strong>. Pero en sumas no cambió nada: sumar es paralelizable, no necesita profundidad. La profundidad ayuda solo cuando cada paso depende del anterior.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C2Dyqkubd5OW2_8gtqycJA.png" /><figcaption>Mismos parámetros, distinta profundidad: el modelo poco profundo se desploma al encadenar saltos; el looped aguanta.</figcaption></figure><p><strong>3. El conocimiento, fuera del modelo.</strong> Monté un RAG: en vez de que el modelo “recuerde”, recupera el dato de una base externa y responde leyéndolo. El detalle honesto: mi modelo de 800K era demasiado pequeño para <em>leer</em> el contexto recuperado (lo ignoraba). Un modelo de 2.000 millones sí lo usaba. RAG te da el conocimiento, no la capacidad de leerlo.</p><p><strong>4. La destilación necesita una brecha grande.</strong> Entrené un modelo “profesor” algo mayor para que enseñara al pequeño imitando sus distribuciones. <strong>No funcionó</strong>: el destilado salió peor. La razón: el profesor apenas sabía más que el alumno, así que no había nada útil que transferir. La destilación que <em>sí</em> funciona es la de brecha enorme, y resulta que ya la había usado sin darme cuenta: TinyStories está generado por GPT-4. El profesor gigante destiló su conocimiento del lenguaje a un dataset simple. Esa fue mi mayor victoria, y era destilación disfrazada.</p><p><strong>5. Pensar más en inferencia funciona, pero necesita un verificador.</strong> En una tarea de sumas donde el modelo acertaba el <strong>40%</strong> a la primera, le dejé generar 16 respuestas. La correcta aparecía entre ellas el <strong>94%</strong> de las veces. El modelo “sabía” la respuesta, solo no la daba siempre primero. Ese salto del 40 al 94 es la esencia de lo que hacen modelos como o1. Pero ojo: si en vez de un verificador solo votaba la respuesta más común, el acierto se quedaba en el 34%, por debajo del original. Los errores eran todos distintos, así que el voto no converge. Moraleja: <strong>el cómputo extra rinde si tienes cómo verificar, no solo generando más.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CAuY_WVZ88Tjp4g92ARsgg.png" /><figcaption>Con un verificador, 16 intentos llevan del 40% al 94%; solo votando se queda en el 34%.</figcaption></figure><p><strong>6. El bajo nivel no siempre acelera.</strong> Intenté acelerar el entrenamiento en CPU: batches más grandes, ajustar hilos, torch.compile, incluso me planteé reescribir en C. Casi todo falló. Batches grandes no ayudaron (el modelo ya saturaba los cores), torch.compile está roto en Windows, y sobre C aprendí algo que no esperaba: en CPU, PyTorch <strong>gana</strong> a C puro, porque por debajo ya usa MKL, álgebra lineal de Intel con décadas de tuning. El propio <a href="https://github.com/karpathy/llm.c">llm.c</a> de Karpathy es más lento que PyTorch en CPU. Reescribir a mano no bate a una librería optimizada.</p><h3>Conclusiones</h3><p>Predije unas ocho optimizaciones a lo largo del experimento. La mayoría fallaron al medirlas. Y las que funcionaron fueron las simples y algorítmicas, no las de bajo nivel. Si tuviera que resumir la jerarquía para exprimir un modelo pequeño: <strong>entrenar mejor (datos limpios) manda sobre entrenar más rápido (tuning), y ambos sobre la arquitectura sofisticada.</strong></p><p>La lección más honesta, sin embargo, es de método: dediqué una noche a medir cosas que “sabía” que iban a funcionar, y me equivoqué una y otra vez. La intuición sobre rendimiento engaña. Mide siempre. Un modelo que cabe en un correo electrónico te enseña más sobre cómo funcionan los grandes que mil páginas de teoría, precisamente porque puedes tocarlo entero y ver dónde te equivocas :)</p><h3>What’s Next</h3><p>Lo natural sería empujar el test-time compute con un verificador de verdad (un reward model minúsculo), y probar el enjambre: muchos modelos diminutos especializados coordinados, en lugar de uno mediano generalista. Es la dirección que más me interesa para <em>edge</em>: inteligencia que quepa donde no llega una GPU.</p><h3>Further reading</h3><ul><li><a href="https://arxiv.org/abs/1706.03762">“Attention Is All You Need”</a> (Vaswani et al., 2017): el paper del Transformer.</li><li><a href="https://arxiv.org/abs/2402.17764">“The Era of 1-bit LLMs”</a> (Microsoft, 2024): BitNet b1.58, los modelos ternarios.</li><li><a href="https://github.com/microsoft/BitNet">bitnet.cpp</a>: la implementación oficial para correr LLMs 1-bit en CPU.</li><li><a href="https://arxiv.org/abs/2305.07759">“TinyStories”</a> (Microsoft, 2023): cómo modelos diminutos hablan coherente si el dataset es simple.</li><li><a href="https://arxiv.org/abs/2106.09685">“LoRA”</a> (Hu et al., 2021): fine-tuning eficiente.</li><li><a href="https://arxiv.org/abs/2005.11401">“RAG”</a> (Lewis et al., 2020): el paper original de retrieval-augmented generation.</li><li><a href="https://github.com/karpathy/nanoGPT">nanoGPT</a> y <a href="https://github.com/karpathy/llm.c">llm.c</a> (Karpathy): los mejores puntos de partida para construir uno tú mismo.</li><li><a href="https://huggingface.co/microsoft/bitnet-b1.58-2B-4T">BitNet b1.58 2B4T en Hugging Face</a>: el modelo 1-bit real de Microsoft, entrenado desde cero con capas BitLinear, descargable.</li><li><a href="https://arxiv.org/abs/2203.11171">“Self-Consistency Improves Chain of Thought”</a> (Wang et al., 2022): el paper del voto por mayoría, la técnica de test-time compute que mido en la palanca 5.</li></ul><h3>Comparte tu experiencia</h3><p>Estoy abierto a colaborar y discutir sobre las posibilidades que ofrece la inteligencia artificial y la ingeniería de software, y cómo trabajar juntos para explorar y construir soluciones en diferentes sectores. Si te interesa el lado agéntico de todo esto (muchos modelos pequeños coordinados, justo el “enjambre” del que hablo en el What’s next), lo cuento paso a paso en <a href="https://medium.com/@jddam/c%C3%B3mo-conectar-odoo-con-agentes-de-ia-usando-model-context-protocol-mcp-y-langgraph-paso-a-paso-65096c36787d">Cómo conectar Odoo con agentes de IA usando MCP y LangGraph</a>. Si tienes ideas, preguntas o simplemente quieres hablar de ello, escríbeme:</p><ul><li><strong>GitHub:</strong> <a href="https://github.com/albertgilopez">https://github.com/albertgilopez</a></li><li><strong>LinkedIn:</strong> <a href="https://www.linkedin.com/in/albertgilopez/">https://www.linkedin.com/in/albertgilopez/</a></li><li><strong>M.IA, tu asistente financiero inteligente:</strong> <a href="https://himia.app/">https://himia.app/</a></li><li><strong>Inteligencia Artificial Generativa en español:</strong> <a href="https://www.codigollm.es/">https://www.codigollm.es/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba90bdc06a2f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Así construimos el MEMEnginy HUB]]></title>
            <link>https://medium.com/@jddam/as%C3%AD-construimos-el-memenginy-hub-a0fd4846c639?source=rss-3723dc84302b------2</link>
            <guid isPermaLink="false">https://medium.com/p/a0fd4846c639</guid>
            <category><![CDATA[university]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[fastapi]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[runcloud]]></category>
            <dc:creator><![CDATA[Albert Gil López]]></dc:creator>
            <pubDate>Wed, 24 Jun 2026 16:29:07 GMT</pubDate>
            <atom:updated>2026-06-24T18:57:12.000Z</atom:updated>
            <content:encoded><![CDATA[<h3>How we built it — la plataforma de la feria de empleo de la Escola d’Enginyeria de la Universidad Autónoma de Barcelona (UAB)</h3><p><em>~2.000 estudiantes, ~75 empresas, entrevistas con matching algorítmico, control de acceso por QR y gamificación. Lo construimos desde la Escola d’Enginyeria de la UAB. Este año la actividad se concentró en el mes previo y en el pico del día del evento. El objetivo: que el año que viene esté encendido desde el inicio de curso.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OqgkBB-ParkrsPef0szEaw.png" /><figcaption>MEMEnginy HUB (MEMEnginy). Escola d’Enginyeria UAB</figcaption></figure><p>La mayoría de aplicaciones tienen el lujo del tiempo. Un pico de tráfico hoy, un bug que se arregla mañana, una carga que sube poco a poco mientras el producto madura.</p><p>MEMEnginy no.</p><p><a href="https://www.memenginy.cat/">MEMEnginy</a> es la feria de empleo de la Escola d’Enginyeria de la Universidad Autónoma de Barcelona (UAB). Este año la plataforma vivió, sobre todo, en dos momentos: el mes previo, cuando los estudiantes se registran, completan su perfil y piden entrevistas con las empresas participantes; y el día del evento, cuando todos entran a la vez. No hay un “lo arreglamos la semana que viene”: si algo se cae a las 12:37 del día del evento, se cae en el peor momento posible.</p><p>Para sostenerlo construimos el <a href="https://app.memenginy.cat/"><strong>MEMEnginy HUB</strong></a>: software propio, <em>made in Enginyeria UAB</em>, que gestiona el registro, los perfiles, las entrevistas, los accesos y la gamificación. No hemos usado ningún proveedor externo más allá de la infraestructura en la cuál se aloja actualmente.</p><p>Este año el HUB lo lanzamos un mes antes y lo hemos “apagado” después del evento. La idea para el curso que viene es que esté <strong>vivo todo el año</strong>, desde el primer día de clase: el punto de encuentro permanente entre estudiantes y empresas, no solo el día de MEMEnginy, que continuará siendo el día para vernos las caras y olernos. La arquitectura que elegimos apunta justo ahí.</p><p>Construir para esto es un problema de ingeniería peculiar. El reto no es solo el volumen: es un pico brutal y correlacionado sobre una base que tiene que ser barata cuando no pasa nada y estar siempre disponible. Este es el resumen honesto de cómo lo montamos, qué decidimos, qué se rompió y qué aprendimos.</p><h3>Background: qué tenía que hacer el sistema</h3><p>Antes de entrar en la arquitectura, el alcance. El día del evento la plataforma tenía que sostener, a la vez:</p><ul><li>Registro y portal de ~2.000 estudiantes y ~75 empresas.</li><li>Entrevistas 1-a-1 entre estudiantes y empresas, asignadas por un <strong>algoritmo de matching</strong>.</li><li>Control de acceso y trazabilidad por <strong>QR</strong> (entrada, zonas, charlas, comida, networking).</li><li><strong>Gamificación</strong>: pasaporte de hitos y badges.</li><li>Analytics en tiempo real para la organización.</li></ul><p>Cinco dominios muy distintos, con perfiles de carga y de criticidad muy distintos, conviviendo en la misma franja horaria.</p><h3>Hands-on: la forma de la solución</h3><p>Decidimos partirlo en servicios independientes en lugar de un único backend. La razón no fue “microservicios porque sí” (que suele ser un error habitual), sino que cada dominio tiene una naturaleza diferente: el QR necesita ser rapidísimo e infalible; el matching es una operación pesada que tarda minutos, aunque esta vez no se ejecutaba en tiempo real; el email puede fallar y reintentarse sin que nadie se entere.</p><figure><img alt="La arquitectura del MEMEnginy HUB: seis servicios (frontend, Hub, tres microservicios y el portal de empresas) sobre una única base de datos PostgreSQL, en Cloud Run." src="https://cdn-images-1.medium.com/max/1024/1*KCuWSTVWlz176Ifp3j8pXw.png" /><figcaption>La arquitectura del MEMEnginy HUB: seis servicios (frontend, Hub, tres microservicios y el portal de empresas) sobre una única base de datos PostgreSQL, en Cloud Run.</figcaption></figure><p>Seis piezas: un frontend (Next.js + Mantine UI), el backend central (Hub, FastAPI), tres microservicios (api-qr, api-matching, api-mail) y el portal de empresas (Mapa, Flask), todos sobre una misma base de datos PostgreSQL. Todo desplegado en Cloud Run (serverless), que escala solo para el pico y no cuesta casi nada cuando no hay nadie. Justo lo que necesita una plataforma que aspira a estar encendida todo el año: barata en reposo, elástica en el pico.</p><h3>El antes del evento: el portal de empresas (mapa.memenginy.cat)</h3><p>El día del evento es la parte visible, pero buena parte del trabajo pasa antes. Ahí entra la otra mitad de la plataforma: <a href="https://mapa.memenginy.cat/"><strong>mapa.memenginy.cat</strong></a>, el portal donde las empresas se registran para participar y gestionan su presencia en la feria, más toda la administración interna que hay detrás. Este año, con esta pieza resolvimos dos <em>pains</em> que arrastrábamos de ediciones anteriores.</p><p><strong>1. La empresa elige dónde quiere estar.</strong> Antes, la organización asignaba a mano la ubicación de cada stand, y cada año llegaban las mismas quejas: “¿por qué me habéis puesto aquí?”. Este año le dimos la vuelta: sobre un mapa interactivo de la feria, <strong>cada empresa selecciona su propia ubicación</strong>. La fricción desaparece porque la decisión deja de ser nuestra. Menos correos, menos negociación, cero “es que yo había pedido…”.</p><p><strong>2. Facturar antes, no meses después.</strong> El otro dolor era administrativo. La facturación de las empresas participantes se nos alargaba <strong>meses</strong> después del evento: un goteo de datos fiscales a perseguir y cobros que llegaban tarde. Este año el propio portal integró el flujo de facturación, y el resultado es el que cualquiera que haya gestionado un evento sabe valorar: <strong>facturamos antes del evento y, en muchos casos, cobramos antes de que empezara</strong>. Lo que antes era trabajo de meses se hizo a tiempo y en su sitio, todo cerrado antes de irnos de vacaciones :)</p><p>Estas dos cosas no son “features bonitas”: son el tipo de problema operativo real que decide si organizar la feria es sostenible o un infierno administrativo, sobre todo cuando el evento empieza a crecer en números. No es lo mismo gestionar 20 empresas que 80. Y son, además, la parte de la plataforma que más sentido tiene tener <strong>encendida todo el año</strong>: el registro de empresas, su perfil y su relación con la Escola vive durante todo el curso.</p><p>A partir de aquí, las decisiones que de verdad importaron.</p><h3>Decisión 1 — Una sola base de datos compartida (y por qué no dos)</h3><p>El portal de empresas (Mapa) y el hub de entrevistas (Hub) son dos aplicaciones, pero comparten <strong>una única base de datos</strong>. No se hablan por API: se hablan por la base de datos.</p><p>Mapa es dueño de las empresas y los stands. El Hub lee esas tablas (con un mapeo de columnas: razon_social → name, etc.) y añade sus propias columnas para lo suyo, las entrevistas.</p><p>El trade-off es que acoplas dos servicios a nivel de datos pero a cambio, te ahorras toda una capa de sincronización, de APIs internas y de consistencia eventual entre dos bases de datos. Para un equipo pequeño y un evento con fecha fija, esa simplicidad valía más que una arquitectura 100% limpia (de todos modos, tenemos la intención de integrar estos dos aplicativos que ahora son dos servicios separados).</p><p>Fue una decisión consciente, y además vino dada porque primero se desarrolló el Mapa y luego el Hub.</p><h3>Decisión 2 — Autenticación en cadena</h3><p>El navegador nunca habla directamente con los microservicios. La identidad viaja en cadena:</p><pre>Navegador (cookie Firebase httpOnly)<br>  -&gt; proxy Next.js<br>     -&gt; Hub Backend (verifica el token de Firebase, busca el rol en la BD)<br>        -&gt; microservicio (API key + cabeceras X-User-ID y X-User-Role)</pre><p>El Hub es el único que entiende de Firebase. Los microservicios confían en él como proveedor de identidad: reciben quién es el usuario y su rol por cabecera, y solo aceptan llamadas con la API key correcta. Las empresas, que entran por Mapa, cruzan al Hub mediante un SSO con tokens personalizados de Firebase. Una sola fuente de verdad de identidad, sin repartir la lógica de auth para seis sitios diferentes.</p><h3>Decisión 3 — Comunicación entre servicios con timeouts a medida</h3><p>Los servicios se llaman entre sí con un patrón sencillo de “publisher” (un cliente HTTP reutilizado, no uno nuevo por petición). Lo interesante no es el patrón, es que <strong>cada llamada se trata según su naturaleza</strong>:</p><ul><li><strong>QR</strong> — timeout 30s, 3 reintentos. Operación rápida e idempotente: reintentar es seguro.</li><li><strong>Email</strong> — 30s, 3 reintentos (lotes de 50). <em>Fire-and-forget</em>: si falla, se reintenta sin bloquear nada.</li><li><strong>Matching</strong> — 300s, <strong>0 reintentos</strong>. Operación pesada (minutos) y no idempotente: reintentar duplicaría trabajo.</li></ul><h3>Decisión 4 — El matching de entrevistas</h3><p>Asignar quién se entrevista con quién es el corazón del producto. No es un “ordena por nota”: es un algoritmo con <strong>7 factores de puntuación</strong>, preferencias mutuas (binarias, no ranking), prioridad para estudiantes de la UAB y un planificador <em>breadth-first round-robin</em> que reparte las entrevistas de forma equilibrada en lugar de llenar a unos pocos. Para no pisarse cuando corre, usa locks a nivel de base de datos (advisory locks).</p><p>El día del evento generó cientos de entrevistas reales a partir de las preferencias de <strong>442 estudiantes</strong> que se habían inscrito para participar.</p><h3>Decisión 5 — QR idempotente y, sobre todo, aislado</h3><p>El QR controla el acceso físico: si falla, hay cola en la puerta. Dos decisiones lo hicieron robusto:</p><ol><li><strong>Firmado con HMAC</strong> (un QR no se puede falsificar) y <strong>escritura idempotente</strong> (un UPSERT con ON CONFLICT): si alguien escanea dos veces, no pasa nada raro.</li><li><strong>Vive en su propio microservicio</strong>, con su propia ruta.</li></ol><p>Volveremos a ella más adelante.</p><h3>El día del evento: el test que ningún test sintético replica</h3><p>Habíamos escalado para el evento y hecho pruebas de carga con usuarios concurrentes. Todo verde.</p><p>A las <strong>12:37</strong> del día del evento, en el slot más cargado, justo en medio de las entrevistas 1 a 1, el backend empezó a devolver errores. <strong>Casi mil respuestas 504</strong>, y el servicio quedó degradado unos <strong>10 minutos</strong>, justo en el peor momento del día.</p><p>La causa no fue “más tráfico”. Fue <strong>tráfico correlacionado</strong>: cuatro fuentes de carga que habíamos analizado por separado coincidieron en el mismo minuto (arranque de las entrevistas + pico de check-ins por QR + cola de walk-in + el polling de los dashboards de la organización). El pool de conexiones a la base de datos, que habíamos dejado deliberadamente pequeño para proteger Cloud SQL, se quedó sin margen y se saturó.</p><figure><img alt="Cronología del incidente del día del evento: a las 12:37, ~1.000 errores 504 y 10 minutos de degradación, con recuperación automática. El QR, aislado, siguió al 100%." src="https://cdn-images-1.medium.com/max/1024/1*Y2KKulLsvEIh0NFir5inTA.png" /><figcaption>Cronología del incidente del día del evento: a las 12:37, ~1.000 errores 504 y 10 minutos de degradación, con recuperación automática. El QR, aislado, siguió al 100%.</figcaption></figure><p>Lo que mantuvo el evento en pie fueron dos cosas:</p><ul><li>El <strong>QR siguió funcionando al 100%</strong>. Como estaba en un microservicio aparte, el atasco del Hub no lo tocó. La gente seguía entrando aunque la web fuera lenta. La decisión 5 se pagó sola.</li><li>La <strong>recuperación fue automática</strong>: al expirar las peticiones encoladas, el pool se liberó solo, y subimos la base de datos en caliente.</li></ul><p>Después optimizamos lo que el incidente dejó claro, con cachés en memoria (thread-safe) para no repetir el mismo trabajo en cada petición. El /api/companies tardaba 3,6 segundos porque firmaba decenas de URLs de ficheros una a una en cada petición. Reutilizar el cliente y cachear las URLs firmadas durante unos minutos lo dejó en 0,08.</p><figure><img alt="Anatomía de /api/companies: el tiempo no se iba en la base de datos, sino en firmar decenas de URLs de GCS en cada petición. Con caché, de 3,6 s a 0,08 s (45×)." src="https://cdn-images-1.medium.com/max/1024/1*6VUrmWMhtr1hCc70m6v0AA.png" /><figcaption>Anatomía de /api/companies: el tiempo no se iba en la base de datos, sino en firmar decenas de URLs de GCS en cada petición. Con caché, de 3,6 s a 0,08 s (45×).</figcaption></figure><h3>Conclusiones</h3><ul><li><strong>Aislar por criticidad funciona.</strong> Lo que no podía caer (el QR) estaba separado de lo que sí podía (la web). No fue suerte, fue la decisión 5.</li><li><strong>Escalar para un evento de un día no es “más grande”, es más correlacionado.</strong> El fallo no fue el volumen, fue la coincidencia. Un test sintético que dispara cada carga por separado nunca lo habría encontrado. La próxima vez: <em>replay</em> del tráfico real del evento anterior.</li><li><strong>La simplicidad fue la decisión correcta para el contexto.</strong> Base de datos compartida, serverless, sin piezas que no necesitábamos. Cada complejidad que no añadimos fue una que no tuvimos que depurar a las 12:37.</li></ul><p>Este año, el MEMEnginy HUB vivió sobre todo un mes y un pico, pero el objetivo del próximo curso es no apagarlo. Que esté encendido desde el primer día de clase, como el punto de encuentro permanente entre estudiantes y empresas, y no solo la ventana de unas semanas antes de la feria. La arquitectura ya apunta ahí: serverless que casi no cuesta en reposo y escala en el pico, servicios aislados que crecen por separado, una base de datos que ya vive todo el año. Pasar de “una feria al año” a “una plataforma todo el año” es, sobre todo, un cambio de ambición, sobre una base que ya hemos construido a lo largo de 12 ediciones.</p><p>El MEMEnginy HUB lo construyeron seis estudiantes de la Escola: <strong>Gabriel Juan Betés</strong> (Project Manager), <strong>Kristian Stoyanov Belkin</strong> (Full Stack), <strong>Joan Marc Samó Rojas</strong> (Backend), <strong>Arnau Ropero Garcia</strong> (Frontend), <strong>Gerard Garcia Gros</strong> y <strong>Aimé Moral Romero</strong> (Coordinadores MEMEnginy 2026). Un servidor estuvo haciendo seguimiento como PM del proyecto, definiendo la arquitectura y apoyando en el desarrollo de los diferentes módulos.</p><p>Creo que una de las claves fue justamente esa, que un equipo de estudiantes de la propia Escola construya y opere algo así. Que se hagan el proyecto suyo, con la suerte de ver lo que han construido en producción utilizado por sus compañeros. Estos son el tipo de proyectos que queremos que los estudiantes hagan mientras están estudiando. Y eso ya dice mucho del talento que formamos en la Escola d&#39;Enginyeria de la Universitat Autònoma de Barcelona (UAB)</p><h3>What’s next</h3><p>El MEMEnginy HUB de este año funcionó, pero un evento así deja siempre una lista de deberes. Estos son los frentes que ya tenemos sobre la mesa para la próxima edición.</p><ul><li><strong>Dimensionar para la carga correlacionada, no para la media. </strong>En lugar de tests sintéticos que disparan cada endpoint por separado, hacer <strong>replay del tráfico real</strong> del evento anterior, que es el único que reproduce la coincidencia que nos tumbó.</li><li><strong>Observabilidad antes de que duela.</strong> Añadir alertas sobre la <strong>utilización del pool</strong> (y no solo sobre CPU/errores), para ver venir la saturación minutos antes del 504. Y un <strong>circuit breaker en el frontend</strong> para degradar con elegancia: si el backend se atasca, mostrar un estado intermedio en vez de un error seco.</li><li><strong>Menos polling, más push.</strong> Buena parte de la carga del día venía del polling de los dashboards de la organización. El siguiente salto es mover esas actualizaciones a <strong>WebSocket o SSE</strong>: en lugar de que cada panel pregunte “¿hay novedades?” cada pocos segundos, que el servidor avise solo cuando las hay. Lo descartamos este año por tiempo.</li><li><strong>Unir las dos mitades.</strong> Hoy el portal de empresas (Mapa) y el hub de entrevistas (Hub) son dos aplicaciones que comparten base de datos pero no código. Fue una decisión consciente y barata, pero la dirección es <strong>integrarlos</strong> en una sola plataforma coherente, sobre todo si queremos que viva todo el año.</li><li><strong>De una feria al año a una plataforma todo el año.</strong> El cambio más grande no es técnico, es estratégico: que el HUB esté encendido desde el primer día de curso, como el punto de encuentro permanente entre estudiantes y empresas. La arquitectura serverless ya lo permite; falta llenarla de uso continuo.</li></ul><p>En definitiva, construir software para un evento que crece cada año es un problema que no se “termina”. Y hacerlo desde dentro de la Escuela, con estudiantes y datos reales, es justo lo que queremos seguir haciendo. Queda abierta la invitación a colaborar, aportar ideas o simplemente comentar cómo lo resolveríais vosotros.</p><p><strong>Para saber más:</strong></p><ul><li>El anuncio de la nueva app: <a href="https://www.memenginy.cat/descobreix-la-nova-app-de-la-memenginy-memenginy-hub/"><strong>Descobreix la nova app de la MEMEnginy — MEMEnginy HUB</strong></a></li><li>La cobertura del evento en La Vanguardia: <a href="https://www.lavanguardia.com/launi/20260326/11499575/match-empresa-tus-suenos-asi-feria-reune-uab-80-empresas-1-500-participantes.html"><strong>Match con la empresa de tus sueños: la feria que reunió en la UAB 80 empresas y 1.500 participantes</strong></a></li><li>El otro experimento de IA + docencia que estoy haciendo en la UAB: <a href="https://medium.com/@jddam/correcci%C3%B3n-de-ex%C3%A1menes-con-ia-en-la-universidad-aut%C3%B3noma-de-barcelona-uab-7a35a8d72331"><strong>Corrección de exámenes con IA en la UAB. Al AI Act le gusta esto.</strong></a></li></ul><h3>Comparte tu experiencia</h3><p>Estoy abierto a colaborar y discutir sobre las posibilidades que ofrece la inteligencia artificial y la ingeniería de software, y cómo trabajar juntos para explorar y construir soluciones en diferentes sectores. Si tienes ideas, preguntas o simplemente quieres hablar de ello, escríbeme:</p><ul><li>GitHub: <a href="https://github.com/albertgilopez">https://github.com/albertgilopez</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/albertgilopez/">https://www.linkedin.com/in/albertgilopez/</a></li><li>M.IA, tu asistente financiero inteligente: <a href="https://himia.app/">https://himia.app/</a></li><li>Inteligencia Artificial Generativa en español: <a href="https://www.codigollm.es/">https://www.codigollm.es/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a0fd4846c639" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GraphRAG vs LightRAG en 2025: Adaptive RAG con GPT-5-nano (caso real UAB)]]></title>
            <link>https://medium.com/@jddam/graphrag-vs-lightrag-en-2025-adaptive-rag-con-gpt-5-nano-caso-real-uab-97e3ce509fba?source=rss-3723dc84302b------2</link>
            <guid isPermaLink="false">https://medium.com/p/97e3ce509fba</guid>
            <category><![CDATA[uab]]></category>
            <category><![CDATA[retrieval-augmented-gen]]></category>
            <category><![CDATA[gpt-5]]></category>
            <category><![CDATA[lightrag]]></category>
            <category><![CDATA[graphrag]]></category>
            <dc:creator><![CDATA[Albert Gil López]]></dc:creator>
            <pubDate>Tue, 19 Aug 2025 15:50:32 GMT</pubDate>
            <atom:updated>2025-09-05T08:04:19.364Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gTm6-w2b9WSqwHcUHsIaQA.png" /><figcaption>AUTOR: GPT-5</figcaption></figure><p>En 2025, el ecosistema de <strong>Retrieval-Augmented Generation (RAG)</strong> ha evolucionado hacia un escenario mucho más sofisticado y competitivo. Entre las múltiples propuestas, dos librerías destacan por su madurez y adopción en producción: <strong>GraphRAG de Microsoft</strong> y <strong>LightRAG de la HKU</strong>. A su alrededor aparecen nuevas alternativas como <strong>LazyGraphRAG</strong>, <strong>MiniRAG</strong> o <strong>RAG-Anything</strong>, que amplían el abanico de posibilidades pero también hacen más compleja la elección.</p><p>El reto es mapear las capacidades de <strong>17 grupos de investigación de la Escuela de Ingeniería de la Universidad Autónoma de Barcelona (UAB) </strong>y responder tanto a <strong>consultas factuales inmediatas</strong> <em>(“¿Qué es SPCOMNAV?”)</em> como a <strong>análisis estratégicos complejos</strong> <em>(“¿Qué oportunidades de colaboración existen entre departamentos?”).</em></p><p>La solución fue diseñar un sistema <a href="https://arxiv.org/abs/2403.14403"><strong>Adaptive RAG</strong></a><strong> </strong>capaz de <strong>seleccionar dinámicamente</strong> entre GraphRAG y LightRAG en función de la complejidad de cada consulta. Para ello, integramos un <em>router</em> inteligente basado en el recién lanzado <strong>GPT-5-nano</strong> ($0.05/1M tokens), optimizado para tareas de clasificación masiva con latencias muy bajas.</p><p><strong>RESULTADO:</strong> “100%” de fiabilidad, un coste de apenas <strong>$0.00136 por consulta</strong> y tiempos de decisión de <em>routing</em> de solo <strong>2–3 segundos</strong>, combinando lo mejor de ambos mundos sin sacrificar velocidad ni profundidad analítica.</p><h3>Background: Las 8 Arquitecturas RAG en 2025</h3><p>Antes de profundizar en GraphRAG y LightRAG, es crucial entender dónde se sitúan en el panorama actual de arquitecturas RAG:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/730/1*4zYEgz35txWLa8DejrjcxQ.jpeg" /><figcaption><em>Fuente: </em><a href="https://x.com/_avichawla/status/1956241967136039197"><em>@_avichawla</em></a></figcaption></figure><h4>1. Naive RAG</h4><ul><li>Arquitectura básica:<em> retrieve → augment → generate</em></li><li>Simple pero efectiva para FAQ y documentación estática (pequeños conjuntos de datos)</li><li>Limita con preguntas complejas o gran volumen de información (sin razonamiento adicional)</li></ul><h4>2. Multimodal RAG</h4><ul><li>Procesa texto, imágenes, audio y video simultáneamente</li><li>Esencial para aplicaciones que requieren comprensión <em>cross-modal</em></li></ul><h4>3. HyDE (Hypothetical Document Embeddings)</h4><ul><li>Genera documentos hipotéticos antes de recuperar</li><li>Útil para <em>queries</em> vagas o exploratorias (amplía el contexto de búsqueda)</li></ul><h4>4. Corrective RAG (CRAG)</h4><ul><li>Autoevaluación y corrección de documentos recuperados</li><li>Ideal para dominios que requieren alta precisión (legal, médico)</li></ul><h4>5. Graph RAG ⭐</h4><ul><li><strong>Aquí se sitúa Microsoft GraphRAG</strong></li><li>Convierte contenido en grafos de conocimiento</li><li>Captura relaciones complejas entre entidades</li><li>Excelente para análisis holístico y <em>“connecting the dots”</em></li></ul><h4>6. Hybrid RAG ⭐</h4><ul><li><strong>Aquí se sitúa LightRAG de HKU</strong></li><li>Combina búsqueda vectorial + grafo + <em>naive</em> simultáneamente</li><li>LightRAG en modo “hybrid” fusiona 3 métodos en paralelo: Local search (entidades específicas), Global search (conceptos amplios) y Naive search (chunks de texto)</li><li>Fusiona y reordena resultados de múltiples fuentes</li></ul><h4>7. Adaptive RAG ⭐</h4><ul><li><strong>Aquí se sitúa nuestro sistema con el router que utiliza GPT-5-nano</strong></li><li>Ajusta la estrategia según complejidad de la <em>query</em></li><li>No fusiona, sino que <strong>selecciona</strong> entre sistemas completos</li><li>Decide dinámicamente:</li></ul><p><em>Queries simples → LightRAG (Hybrid RAG)<br>Queries complejas → GraphRAG (Graph RAG)</em></p><h4>8. Agentic RAG</h4><ul><li>Agentes autónomos que orquestan múltiples fuentes</li><li>Planificación, razonamiento y memoria para tareas complejas</li><li>Combina lo mejor de RAG con agentes de IA</li></ul><h4>GraphRAG (Microsoft Research)</h4><p>Lanzado en julio 2024 y actualizado a v1.0 en diciembre 2024, GraphRAG es el framework de Microsoft que ha cambiado el paradigma del RAG tradicional mediante <em>clustering</em> jerárquico de comunidades para como mencionan ellos: <em>“unlock LLM discovery on narrative private data”</em>.</p><p>Está basado en el<strong> algoritmo Leiden, </strong>una mejora del algoritmo Louvain desarrollada en la Universidad de Leiden. Su función es detectar <strong>comunidades</strong><em> (grupos de nodos densamente conectados)</em> en grafos grandes.</p><p>Funciona en tres fases:</p><ol><li>Mueve nodos entre comunidades para maximizar la modularidad.</li><li>Se asegura que cada comunidad esté bien conectada internamente <em>(ventaja sobre Louvain, que puede crear comunidades desconectadas).</em></li><li>Colapsa comunidades en super-nodos y repite el proceso.</li></ol><p>El <strong>clustering jerárquico</strong> significa que GraphRAG crea múltiples niveles de abstracción. En nuestro caso de uso:</p><ul><li><strong>Nivel 0</strong>: Entidades individuales (ej: “SPCOMNAV”, “Dr. García”).</li><li><strong>Nivel 1</strong>: Comunidades pequeñas (ej: “Grupos de Telecomunicaciones”).</li><li><strong>Nivel 2</strong>: Comunidades mayores (ej: “Investigación en Ingeniería”).</li><li><strong>Nivel N</strong>: Vista global del dataset completo.</li></ul><p>GraphRAG utiliza este pipeline en 4 fases:</p><p><strong>1. Ingestion Layer</strong>:</p><ul><li>Divide documentos en <em>chunks</em> de ~300 tokens.</li><li>Extrae metadatos y prepara el contenido para procesamiento.</li></ul><p><strong>2. Graph Construction Layer</strong>:</p><ul><li>Un LLM extrae entidades y relaciones de cada <em>chunk</em>.</li><li>Construye un grafo inicial con todas las conexiones detectadas.</li><li>Aplica Leiden para detectar comunidades jerárquicas.</li></ul><p><strong>3. Retrieval Layer</strong>:</p><ul><li>Para <em>queries</em> locales: busca entidades específicas en el grafo.</li><li>Para <em>queries</em> globales: navega la jerarquía de comunidades.</li><li>Selecciona el nivel de abstracción apropiado según el alcance de la pregunta.</li></ul><p><strong>4. Generation Layer</strong>:</p><ul><li>Sintetiza información de múltiples fuentes (nodos y comunidades relevantes).</li><li>Genera una respuesta coherente usando <em>summaries</em> de comunidad.</li></ul><p>Los <strong>community summaries</strong> son resúmenes automáticos generados por el LLM para cada comunidad detectada, facilitando respuestas globales sin recorrer todo el dataset cada vez:</p><pre><br># Ejemplo simplificado del proceso de resumen comunitario<br>for community in detected_communities:<br>    entities = get_entities_in_community(community)<br>    relationships = get_relationships(entities)<br>    <br>    summary_prompt = f&quot;&quot;&quot;<br>    Summarize this community of {len(entities)} entities:<br>    Entities: {entities}<br>    Relationships: {relationships}<br>    Create a coherent summary of what this group represents.<br>    &quot;&quot;&quot;<br>    <br>    community.summary = llm.generate(summary_prompt)</pre><p>Esto permite a GraphRAG responder preguntas globales aprovechando resúmenes precomputados de cada comunidad, en lugar de procesar todo el dataset en cada consulta.</p><p>Ahora, las queries son relativamente <strong>lentas</strong> (30–40 segundos por consulta) debido a que debe atravesar <strong>múltiples niveles de la jerarquía de grafos </strong>y<strong> combinar información de múltiples comunidades</strong> antes de contestar.</p><p>Además, <strong>cada nivel puede requerir procesamiento adicional con el LLM</strong> (p.e. para generar resúmenes), sin olvidar la <strong>complejidad computacional</strong> de las operaciones <em>~O(n log n)</em> para grafos grandes.</p><h4>LightRAG (University of Hong Kong)</h4><p>Publicado en octubre 2024 <a href="https://arxiv.org/abs/2410.05779">(arXiv:2410.05779)</a>, LightRAG propone <em>“Simple and Fast Retrieval-Augmented Generation”</em>. Es una implementación de una arquitectura <strong>Hybrid RAG</strong> que <strong>fusiona</strong> múltiples métodos de búsqueda en paralelo mediante un sistema de recuperación de dos niveles.</p><p>LightRAG implementa dos niveles de recuperación que operan simultáneamente:</p><p><strong>1. Low-Level Retrieval (Recuperación de Bajo Nivel). </strong>Recuperar entidades específicas y sus atributos directos mediante una búsqueda vectorial directa + extracción de nodos específicos del grafo.</p><p><strong>Ejemplo</strong>: <em>Query</em> “¿Qué es SPCOMNAV?” → Busca el nodo <em>SPCOMNAV</em> en el grafo + relaciones inmediatas asociadas. ~O(log n) usando índices vectoriales eficientes (FAISS u otro motor de similitud).</p><p><strong>2. High-Level Retrieval (Recuperación de Alto Nivel). </strong>Sintetizar temas y conceptos amplios relacionados con la consulta madiante navegación por clusters de nodos relacionados temáticamente.</p><p><strong>Ejemplo</strong>: <em>Query</em> “tendencias en investigación” → Atraviesa clusters temáticos en el grafo (ej: grupos de temas de investigación) para identificar tendencias globales. ~O(k · log n) donde <em>k</em> es el número de clusters relevantes explorados.</p><p>LightRAG ofrece cuatro modos de operación configurables:</p><pre><br># Ejemplos de modos de consulta en LightRAG<br>rag.query(query, mode=&quot;local&quot;)    # Solo búsqueda de entidades específicas (low-level)<br>rag.query(query, mode=&quot;global&quot;)   # Solo búsqueda de conceptos amplios (high-level)<br>rag.query(query, mode=&quot;naive&quot;)    # Solo búsqueda en chunks de texto planos<br>rag.query(query, mode=&quot;hybrid&quot;)   # FUSIÓN de los 3 anteriores (por defecto)<br><br># Proceso simplificado del modo &quot;hybrid&quot; (Hybrid RAG)<br>def hybrid_retrieval(query):<br><br>    # Ejecuta los 3 métodos en PARALELO<br>    local_results = local_search(query)    # Low-level entities<br>    global_results = global_search(query)  # High-level concepts<br>    naive_results = naive_search(query)    # Text chunks<br>    <br>    # Fusiona y reordena todos los resultados<br>    all_results = local_results + global_results + naive_results<br>    return merge_and_rank(all_results)</pre><p><strong>Por esto LightRAG es <em>Hybrid RAG</em></strong>: no elige un método u otro, sino que <strong>fusiona múltiples métodos simultáneamente</strong> para aprovechar lo mejor de cada uno.</p><p>A diferencia de GraphRAG, que suele requerir reconstruir todo el índice de grafos ante cualquier cambio, LightRAG permite <strong>actualización incremental</strong> de su índice:</p><pre><br># Proceso de actualización incremental en LightRAG<br>def incremental_update(new_document):<br><br>    # 1. Extrae nuevas entidades y relaciones del documento<br>    new_entities = extract_entities(new_document)<br>    new_relations = extract_relations(new_document)<br>    <br>    # 2. Deduplica contra el índice existente<br>    unique_entities = deduplicate(new_entities, existing_entities)<br>    <br>    # 3. Solo indexa lo nuevo (NO reconstruye todo desde cero)<br>    if unique_entities:<br>        entity_index.add(unique_entities)            # O(m) donde m = nuevas entidades<br>        update_vector_embeddings(unique_entities)    # Actualiza embeddings<br>    <br>    # 4. Actualiza grafo localmente con nuevos nodos/aristas<br>    graph.add_nodes(unique_entities)<br>    graph.add_edges(new_relations)<br>    <br>    # Total: O(m) vs O(n) de reconstrucción completa</pre><p>Otra ventaja es que LightRAG logra latencias de <strong>20–100 ms</strong> por consulta gracias a:</p><p><strong>1. Sin Navegación Jerárquica</strong>:</p><ul><li>Acceso directo a entidades vía índice vectorial optimizado.</li><li>No atraviesa múltiples niveles como GraphRAG, reduciendo pasos intermedios.</li></ul><p><strong>2. Búsqueda Vectorial Optimizada</strong>:</p><ul><li>Usa estructuras como FAISS para búsqueda aproximada en O(log n) con miles de embeddings.</li><li>Índices precomputados en memoria evitan cálculos repetitivos.</li></ul><p><strong>3. Grafo Local, No Global</strong>:</p><ul><li>Solo explora vecinos inmediatos (<em>1-hop neighbors</em>) en el grafo alrededor de entidades relevantes.</li><li>No requiere consolidar información de comunidades lejanas ni generar resúmenes globales costosos.</li></ul><p><strong>4. Sin LLM en el <em>Critical Path</em></strong>:</p><ul><li>El LLM solo se usa para generar la respuesta final (síntesis), <strong>no</strong> para la etapa de búsqueda o navegación.</li><li>A diferencia de GraphRAG, no hay múltiples llamadas al LLM durante la recuperación, solo al final para formulación de la respuesta.</li></ul><h4>EXTRA — Event Loop: Issue Conocido</h4><p>Un error conocido <em>“Event loop is closed”</em> está reportado en GitHub <em>(</em><a href="https://github.com/HKUDS/LightRAG/issues/209"><em>Issue #209</em></a><em>)</em> y afecta principalmente a entornos Windows al usar LightRAG.</p><ul><li>LightRAG usa asyncio para paralelización. En Windows, el ProactorEventLoop tiene problemas al cerrarse, y las tareas pendientes no se cancelan correctamente, cerrando el loop de evento inesperadamente tras la primera consulta.</li><li><strong>Solución 1:</strong> Cambiar la política de event loop en Windows antes de usar LightRAG.</li></ul><pre>import asyncio asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())</pre><ul><li><strong>Solución 2:</strong> Usar nest_asyncio para permitir reusar el loop.</li></ul><pre>import nest_asyncio nest_asyncio.apply()</pre><ul><li><strong>Solución 3:</strong> Utilizar un <em>wrapper</em> que implementamos que garantiza el 100% de fiabilidad, aislando cada consulta en un loop independiente.</li></ul><p><strong><em>NOTA</em></strong><em>: Este es un problema de la librería, no específico del caso de uso.</em></p><p>En resumen, estos son algunos de los puntos fuertes de LightRAG:</p><ul><li>Respuestas en <strong>20–100 ms</strong> gracias a búsqueda directa sin jerarquías profundas.</li><li>Actualizaciones incrementales <strong>O(m)</strong>, críticas para datos dinámicos (p. ej. añadir publicaciones nuevas en tiempo real).</li><li>La propia librería ofrece una UI incluida y API compatible con <em>Ollama</em> para integrar fácilmente LLMs sin depender de proveedores externos.</li><li>Integración con <strong>RAG-Anything</strong> para procesamiento <strong>multimodal</strong> (texto, imágenes, tablas) desde 2025.</li></ul><h3>Hands-on: Mapeo de 17 Grupos de Investigación UAB</h3><ul><li><strong>17 grupos de investigación</strong> en 7 departamentos de la Escuela de Ingeniería de la Universidad Autónoma de Barcelona (UAB).</li><li><strong>5 <em>clusters</em> temáticos principales</strong>:</li></ul><ol><li>Digital Technologies &amp; Communications (35%)</li><li>Security &amp; Information Protection (20%)</li><li>Environmental &amp; Biotechnology (20%)</li><li>Control Systems &amp; Automation (15%)</li><li>Hardware &amp; Systems Design (10%)</li></ol><ul><li><strong>Rango temporal de datos</strong>: 1990–2024 (p.e., GENOCOV activo desde 1990).</li><li><strong>~100 publicaciones</strong> indexadas en total (papers, tesis, proyectos relevantes).</li></ul><p>La idea es que el sistema pueda:</p><ol><li><strong>Realizar consultas sobre hechos de manera inmediata </strong>(&lt; 100 ms por respuesta): p.e.“¿Qué es SPCOMNAV?”</li><li><strong>Análisis estratégicos profundos</strong>: p. ej. “Oportunidades de colaboración interdepartamental”.</li><li><strong>Actualización incremental</strong> al añadir nuevas publicaciones (sin reconstruir todo desde cero).</li><li><strong>Escalabilidad</strong>: capacidad para manejar 1,000–10,000 consultas/mes sin degradar rendimiento.</li><li><strong>Costo controlado</strong>: infraestructura + API LLM.</li></ol><h4>1. Arquitectura con Router GPT-5-nano</h4><pre>┌─────────────────────────────────────────┐<br>│            Usuario: Query               │<br>└─────────────────────────────────────────┘<br>                    │<br>                    ▼<br>┌─────────────────────────────────────────┐<br>│    GPT-5-nano Router (Adaptive RAG)     │<br>│   ($0.000023/decisión, 2–3 s)           │<br>│   reasoning.effort: &quot;minimal&quot;           │<br>└─────────────────────────────────────────┘<br>         │                    │<br>         ▼                    ▼<br>    [80% casos]          [20% casos]<br>┌──────────────┐    ┌──────────────────┐<br>│   LightRAG   │    │     GraphRAG     │<br>│  (Hybrid RAG)│    │    (Graph RAG)   │<br>│   (0.02–2 s) │    │     (30–40 s)    │<br>└──────────────┘    └──────────────────┘</pre><ul><li><strong>Nivel superior</strong>: <em>Adaptive RAG</em> — un router inteligente (utilizando el nuevo modelo GPT-5-nano) que clasifica cada pregunta y selecciona el método adecuado.</li><li><strong>Nivel inferior (izq.)</strong>: LightRAG = Hybrid RAG (fusiona 3 métodos de recuperación en paralelo). Atiende ~80% de casos.</li><li><strong>Nivel inferior (der.)</strong>: GraphRAG = Graph RAG (navegación jerárquica con grafo). Atiende ~20% de casos.</li></ul><h3>2. Router Inteligente con GPT-5-nano</h3><p><strong>¿Por qué GPT-5-nano?</strong> OpenAI presentó GPT-5 en julio de 2025 y presentó este modelo específicamente para tareas masivas de enrutamiento/clasificación: costo $0.05 por 1M tokens (20× más barato que GPT-4o), con capacidad de respuesta rápida. Perfecto para decidir, por cada consulta, si usar LightRAG o GraphRAG.</p><pre>from openai import OpenAI<br><br>class IntelligentRouter:<br>    &quot;&quot;&quot;<br>    Router que usa GPT-5-nano para clasificación ultrarrápida de consultas.<br>    Emplea la nueva feature de &#39;minimal reasoning&#39; para acelerar respuestas.<br>    &quot;&quot;&quot;<br><br>    def __init__(self):<br>        self.client = OpenAI()<br>        self.model = &quot;gpt-5-nano&quot;<br>        self.routing_prompt = &quot;&quot;&quot;<br>        Classify this query for RAG system routing:<br>        <br>        Categories:<br>        - &#39;lightrag&#39;: Specific facts, entities, quick lookups<br>        - &#39;graphrag&#39;: Global analysis, patterns, themes, relationships<br>        <br>        Query: {query}<br>        <br>        Respond with ONLY the category name.<br>        &quot;&quot;&quot;<br>    <br>    async def route_query(self, query: str) -&gt; dict:<br>        &quot;&quot;&quot;Usa GPT-5-nano (razonamiento mínimo) para determinar ruta óptima.&quot;&quot;&quot;<br>        response = await self.client.responses.create(<br>            model=self.model,<br>            input=self.routing_prompt.format(query=query),<br>            reasoning={&quot;effort&quot;: &quot;minimal&quot;},   # minimiza pasos de pensamiento<br>            text={&quot;verbosity&quot;: &quot;low&quot;}          # respuesta concisa (una palabra)<br>        )<br>        decision = response.output_text.strip().lower()<br>        return {<br>            &quot;route&quot;: decision,  # &#39;lightrag&#39; o &#39;graphrag&#39;<br>            &quot;confidence&quot;: self._calculate_confidence(query, decision),<br>            &quot;cost&quot;: 0.000023,  # Costo real estimado por decisión (23e-6 USD)<br>            &quot;reasoning&quot;: &quot;GPT-5-nano classification&quot;,<br>            &quot;complexity&quot;: &quot;low&quot; if decision == &quot;lightrag&quot; else &quot;high&quot;<br>        }</pre><h3>3. Sistema Adaptive RAG Completo</h3><p>Finalmente, integramos todo en la clase principal del sistema:</p><pre>class AdaptiveRAGSystem:<br>    &quot;&quot;&quot;<br>    Sistema Adaptive RAG que selecciona dinámicamente entre <br>    GraphRAG y LightRAG según la complejidad de cada query.<br>    &quot;&quot;&quot;<br>    def __init__(self):<br>        self.router = IntelligentRouter()<br>        self.lightrag = RobustLightRAGWrapper(&quot;./lightrag_index&quot;) # wrapper que soluciona el problema del Event Loop<br>        self.graphrag = GraphRAGWrapper(&quot;./graphrag_project&quot;)     <br>        self.metrics = {&quot;total_queries&quot;: 0, &quot;lightrag&quot;: 0, &quot;graphrag&quot;: 0}<br>    <br>    async def query(self, user_query: str) -&gt; dict:<br>        &quot;&quot;&quot;Procesa una query utilizando el router para elegir la vía óptima.&quot;&quot;&quot;<br>        <br>        start_time = time.time()<br>        # 1. Decisión de routing<br>        routing = await self.router.route_query(user_query)<br>        routing_time = time.time() - start_time<br>        <br>        # 2. Ejecuta la query en el sistema elegido<br>        if routing[&quot;route&quot;] == &quot;lightrag&quot;:<br>            answer_text = self.lightrag.query(user_query, mode=&quot;hybrid&quot;)<br>            self.metrics[&quot;lightrag&quot;] += 1<br>        else:<br>            answer_text = self.graphrag.query(user_query, method=&quot;global&quot;)<br>            self.metrics[&quot;graphrag&quot;] += 1<br>        <br>        execution_time = time.time() - start_time - routing_time<br>        self.metrics[&quot;total_queries&quot;] += 1<br>        return {<br>            &quot;query&quot;: user_query,<br>            &quot;answer&quot;: answer_text,<br>            &quot;routing&quot;: routing,<br>            &quot;times&quot;: {<br>                &quot;routing&quot;: f&quot;{routing_time:.2f}s&quot;,<br>                &quot;execution&quot;: f&quot;{execution_time:.2f}s&quot;,<br>                &quot;total&quot;: f&quot;{time.time() - start_time:.2f}s&quot;<br>            },<br>            &quot;cost&quot;: routing[&quot;cost&quot;] + self._calculate_query_cost(routing[&quot;route&quot;])<br>        }</pre><p><em>(En nuestro caso, </em><em>GraphRAGWrapper es una abstracción similar a LightRAGWrapper para encapsular llamadas síncronas a GraphRAG.)</em></p><p>Algunas métricas del sistema en producción:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/954/1*pufTpVgRD0Nkg4GvKDC7bA.png" /><figcaption><strong>Observaciones:</strong> Para consultas factuales concretas, el router suele responder en ~1–3 s y LightRAG entrega la respuesta casi instantáneamente, manteniendo el total ~1–5 s. Para consultas estratégicas/globales, el router aún responde rápido (2–3 s) pero GraphRAG requiere ~30–40 s para el análisis profundo, llevando el total a ~35–45 s. En todos los casos el router añade una sobrecarga mínima comparado con el tiempo total.</figcaption></figure><p>La gran mayoría de consultas diarias son básicas, y ahí es donde LightRAG destaca por su rapidez. Otras consultas de alto nivel son de tipo estratégicas, donde GraphRAG aporta valor pese a una latencia mayor. La ventaja de estas arquitecturas dinámicas con un sistema híbrido por debajo es evitar gastar +30 segundos en el 80% de preguntas que no lo requieren, sin dejar de cubrir el 20% de preguntas complejas con sistemas que dan vuenos resultados.</p><p>Esta es una estimación de costes con un escalado para 1000 y 10.000 consultas diarias:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/962/1*Tdt0F80sIa0RsPY76wGHkw.png" /><figcaption><strong>Observaciones: </strong><em>Estimado asumiendo ~80% consultas van a LightRAG (ejecutadas en local o con modelo menor, costo marginal) y ~20% a GraphRAG (ejecutado con GPT-4o o similar) + costo del router GPT-5-nano por decisión.</em></figcaption></figure><p>Incluso con 10k consultas al mes (~330 diarias), el costo total se mantuvo alrededor de $30 USD. El router GPT-5-nano aporta una fracción mínima del costo (&lt;1%), y las consultas GraphRAG (20%) dominan el gasto. Aun así, comparar $30 con una alternativa de usar siempre GPT-4/GraphRAG para todo (que habría sido mucho más costosa) evidencia el ahorro significativo del enfoque adaptativo.</p><p>Algunos ejemplos de preguntas reales:</p><p><strong>Query LightRAG, ~0.02 s</strong></p><p>Q: <em>“Which research group specializes in circular economy?”</em></p><p>A: <strong>GENOCOV</strong> (Group of biological treatment of liquid and gaseous effluents) <em>Especialización:</em> Economía circular a través de:</p><ul><li>Procesos biológicos de tratamiento de aguas residuales.</li><li>Recuperación de recursos a partir de corrientes de desecho.</li><li>Ingeniería ambiental sostenible.</li></ul><p><strong>Query GraphRAG, ~39 s</strong></p><p>Q: <em>“What are the main collaboration opportunities between departments?”</em></p><p>A: <em>El análisis identifica 5 grandes oportunidades interdisciplinarias:</em></p><p><strong>1. AI-Biomedical Convergence</strong></p><ul><li><strong>Departamentos involucrados:</strong> Information &amp; Communications + Chemical/Biological.</li><li><strong>Grupos clave:</strong> WIN, CSCG + GENOCOV, GECT.</li></ul><p>AI aplicada a descubrimiento de fármacos, medicina personalizada.</p><p><strong>2. Smart Cities &amp; IoT Platforms</strong></p><ul><li><strong>Departamentos:</strong> Telecommunications + Computer Architecture + Electronic Engineering.</li><li><strong>Grupos clave:</strong> SPCOMNAV, ASAC + HPC4EAS + DCSI.</li></ul><p>Sistemas urbanos inteligentes, optimización de tráfico, gestión energética.</p><p><strong>3. Quantum Technologies Initiative</strong></p><ul><li><strong>Departamentos:</strong> Information &amp; Communications + Telecommunications.</li><li><strong>Grupos clave:</strong> Q-CSI + SPCOMNAV.</li></ul><p>Redes cuánticas, comunicaciones seguras de próxima generación.</p><p><strong>4. Sustainable Tech Framework</strong></p><ul><li><strong>Iniciativa transversal (varios departamentos)</strong>.</li><li><strong>Grupos clave:</strong> GENOCOV + GECT + equipos de <em>smart grids</em>.</li></ul><p>Economía circular, integración de energías renovables, tecnología verde.</p><p><strong>5. Security &amp; Privacy Platform</strong></p><p><strong>Departamentos:</strong> Information &amp; Communications + (colaboración amplia con otros).</p><ul><li><strong>Grupos clave:</strong> CSCG + equipos de seguridad de redes.</li></ul><p>Ciberseguridad para IoT, aplicaciones de blockchain, privacidad de datos.</p><h3>Conclusiones</h3><p>La experiencia en la UAB demuestra que no existe un ganador único en la batalla <strong>GraphRAG vs LightRAG</strong>. La clave está en combinarlos bajo un enfoque <strong>Adaptive RAG</strong>, donde un router inteligente basado en <strong>GPT-5-nano</strong> decide en tiempo real qué arquitectura aplicar en cada consulta. Este equilibrio aporta rapidez en el 80% de los casos y profundidad analítica en el 20% restante, con un coste controlado y sin sacrificar fiabilidad.</p><p>La lección principal es clara: en producción no basta con elegir una librería de moda, sino diseñar sistemas capaces de adaptarse dinámicamente a las necesidades de cada usuario, cada query y sobretodo el caso de uso específico. El impacto práctico es evidente: ahorro de costes, reducción de latencias y escalabilidad real sin comprometer la calidad de las respuestas.</p><h3>What’s next</h3><p>Quedan aún retos por explorar antes de consolidar estos sistemas como estándar. Algunos caminos inmediatos:</p><ul><li><strong>Integración multimodal</strong>: extender el Adaptive RAG a consultas que combinen texto, imágenes y datos tabulares.</li><li><strong>Agentes sobre RAG</strong>: conectar este router con frameworks como LangGraph para orquestar flujos más complejos, incorporando planificación y memoria a largo plazo.</li><li><strong>Optimización de coste y latencia</strong>: experimentar con versiones aún más ligeras de los modelos clasificadores, o incluso modelos especializados entrenados in-house para tareas de routing.</li><li><strong>Aplicaciones verticales</strong>: replicar esta arquitectura en otros sectores más allá de la investigación universitaria: finanzas, salud, administración pública.</li></ul><p>En definitiva, <strong>el ecosistema RAG en 2025 es más un sistema vivo que un conjunto de librerías aisladas</strong>. La invitación queda abierta: explorar, probar y compartir nuevas combinaciones que lleven la tecnología un paso más allá de lo que hoy entendemos por técnicas de recuperación aumentada o RAG. Puedes leer otros artículos publicados hace un tiempo aquí:</p><ul><li><a href="https://medium.com/@jddam/comparativa-naive-rag-vs-react-agent-utilizando-llamaindex-24fb11577574"><strong>Comparativa Naive RAG vs ReAct Agent utilizando LlamaIndex</strong></a></li></ul><p><strong>Comparte tu experiencia:</strong></p><p>Estoy abierto a colaborar y discutir sobre las posibilidades que ofrece la inteligencia artificial y cómo trabajar juntos para explorar y construir soluciones en diferentes sectores. Si tienes ideas, preguntas o simplemente quieres hablar de ello, escríbeme:</p><ul><li>GitHub: <a href="https://github.com/albertgilopez">https://github.com/albertgilopez</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/albertgilopez/">https://www.linkedin.com/in/albertgilopez/</a></li><li>M.IA, tu asistente financiero inteligente: <a href="https://himia.app/">https://himia.app/</a></li><li>Inteligencia Artificial Generativa en español: <a href="https://www.codigollm.es/">https://www.codigollm.es/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=97e3ce509fba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Corrección de exámenes con IA en la Universidad Autónoma de Barcelona (UAB).]]></title>
            <link>https://medium.com/@jddam/correcci%C3%B3n-de-ex%C3%A1menes-con-ia-en-la-universidad-aut%C3%B3noma-de-barcelona-uab-7a35a8d72331?source=rss-3723dc84302b------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a35a8d72331</guid>
            <category><![CDATA[uab]]></category>
            <category><![CDATA[openai]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[pipeline]]></category>
            <category><![CDATA[exam]]></category>
            <dc:creator><![CDATA[Albert Gil López]]></dc:creator>
            <pubDate>Fri, 25 Jul 2025 04:46:36 GMT</pubDate>
            <atom:updated>2025-07-26T03:35:01.543Z</atom:updated>
            <content:encoded><![CDATA[<h3><em>Corrección de exámenes con IA en la Universidad Autónoma de Barcelona (UAB). Al AI Act le gusta esto.</em></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/559/1*UJWrQ7Z1T52bKsIO2GGgzA.jpeg" /><figcaption>Jornada Innovación Docent — Escola d’Enginyeria Universitat Autònoma de Barcelona (UAB)</figcaption></figure><p>La corrección manual de exámenes (sobre todo escritos, pero también en formato digital) es actualmente un proceso demasiado artesanal y el talón de Aquiles de muchos profesores. En asignaturas con muchos estudiantes matriculados, los profesores invierten fines de semana enteros en evaluar las pruebas, en un <strong>proceso monótono</strong>, <strong>lento </strong>y que <strong>consume tiempo </strong>que se podría invertir en otras<strong> tareas de valor, </strong>como <strong>tutorías </strong>o<strong> diseñar rutas de aprendizaje. </strong>En consecuencia, se retrasa el<strong> feedback al estudiante </strong>o el que recibe no le aporta nada (cuando solo se trata de un valor numérico.) Cuando por fin el alumno recibe la nota, suele ser <strong>demasiado tarde para aprender del error</strong>. Además, esta granularidad individual dificulta detectar <strong>patrones de fallo comunes</strong> o <strong>tendencias globales</strong> en la clase.</p><p>Estas dificultades y el auge actual de tecnologías de IA me motivaron a presentar en la <em>Jornada d’Innovació Docent 2025</em> de la Escola d’Enginyeria de la Universidad Autònoma de Barcelona (UAB) un pipeline automatizado de corrección con IA enfocado en acelerar este proceso y mejorar el feedback para sus alumnos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JwAtY7p5pDdSOn_crYIWEQ.png" /><figcaption>Fig. 1: Guilles Deleuze, filósofo francés del siglo XX, nos invita a criticar la base de nuestras creencias para poder crear nuevas realidades. Todo lo que vemos tiene una identidad. Nosotros se la damos. Pensamos que una nota significa conocimiento, que un examen significa comprensión… Para poder crear nuevas realidades tenemos que utilizar nuevas miradas y perspectivas. Pasó con las calculadoras. Volverá a pasar con la IA.</figcaption></figure><p>Ahora bien, <strong>automatizar la corrección de exámenes con IA plantea cuestiones legales y éticas</strong>. El recientemente aprobado <a href="https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai"><strong>AI Act europeo</strong></a> considera de <em>alto riesgo</em> los sistemas de IA utilizados en educación para determinar resultados académicos (por ejemplo, la calificación de exámenes). Esto implica obligaciones estrictas en su uso, incluyendo <strong>supervisión humana, trazabilidad y mitigación de sesgos</strong>. En la práctica y desde un punto de vista jurídico, conviene <strong>diferenciar “corregir” de “evaluar”</strong><em> (algo en lo que estuvimos debatiendo en la jornda). </em>Podemos dejar que una IA corrija ejercicios — es decir, asigne puntuaciones parciales o sugiera comentarios siguiendo unas rúbricas predefinidas— , pero la <em>evaluación</em> final (la decisión sobre la nota y el feedback oficial) debe seguir siendo responsabilidad del profesor. Esta distinción garantiza que la herramienta respalde al docente sin suplantar su juicio, cumpliendo así con la normativa vigente y con la ética profesional docente.</p><h3>Background</h3><p><em>El problema de la corrección manual no es nuevo</em>: como mencionábamos, es <strong>lenta</strong>, consume recursos que el profesorado podría dedicar a preparar mejores clases o investigar, y suele entregar un <strong>feedback poco útil y tardío</strong> a los estudiantes. Por si fuera poco, los profesores difícilmente pueden <strong>analizar tendencias</strong> o <strong>datos globales</strong> de los resultados — como qué preguntas resultaron más difíciles o cuáles fueron los errores más comunes — debido al formato tradicional de corrección aislada en papel o al no disponer de herramientas cuando se usan formatos digitales.</p><p>En los últimos años han surgido <strong>soluciones tecnológicas para agilizar la evaluación</strong>. Plataformas como <a href="https://www.gradescope.com/"><em>Gradescope</em></a><em> </em>permiten digitalizar exámenes escritos (mediante escáner o fotos) y aplicar algoritmos para agrupar respuestas similares, facilitando la calificación por lotes. Grandes universidades como Harvard, MIT o Stanford ya emplean Gradescope para <strong>ahorrar tiempo al calificar y obtener una visión clara del desempeño de los estudiantes</strong>. Estas herramientas combinan reconocimiento de texto, evaluación automática en preguntas cerradas e incluso asistencias para preguntas abiertas mediante rúbricas, logrando <strong>reducir a la mitad</strong> (o más) el tiempo dedicado a corregir. No obstante, suelen requerir que el examen se adapte a formatos prediseñados (p. ej. test de opciones, respuestas en recuadros) o que el profesor defina de antemano las respuestas esperadas para compararlas automáticamente.</p><p>La aproximación utilizada no dista mucho de esa idea, pero el enfoque y uso de la tecnología es diferente, y aprovecha todo el potencial de tecnologías relativamente nuevas como los <strong>Large Language Models</strong> o <strong>LLMs</strong>.</p><p>En la asignatura <strong>Arquitectura y Tecnologías de Software (ATS)</strong> de la UAB, de tercer curso del Grado en Ingeniería Informática, se decidió ir un paso más allá. Se planteó un <strong>caso de uso real</strong>: un examen parcial de ATS con unas 70 pruebas escritas a mano, incluyendo preguntas tipo test, de desarrollo teórico y consultas prácticas de código (MongoDB). El objetivo del proyecto era <strong>transformar la corrección artesanal en un “pipeline” industrial</strong> eficiente, manteniendo la calidad de la evaluación pero liberando al profesor de las tareas mecánicas y aburridas. En esencia, convertir <strong>papel en datos estructurados</strong> listos para analizar.</p><p>A continuación, se detalla el <em>pipeline</em> técnico presentado en la jornada, que consiguió corregir <strong>~70 exámenes en apenas 20 minutos</strong>, lejos de las 2–3 horas<strong> </strong>que hubiera requerido hacerlo de manera manual (caso real).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lzS-nyx3UrXimorEvZo8Dg.png" /><figcaption>Fig. 2: La figura muestra en detalle los diferentes módulos del pipeline técnico presentado en la Jornada d’Innovació Docent de la Escola d’Enginyeria de la Universidad Autónoma de Barcelona UAB), que consiguió corregir <strong>~70 exámenes en apenas 20 minutos</strong>, lejos de las 2–3 horas<strong> </strong>que hubiera requerido hacerlo de manera manual (caso real).</figcaption></figure><h3>Hands-on: Pipeline de corrección con IA paso a paso</h3><p>El pipeline encadena varias <strong>fases automatizadas</strong>, combinando Large Language Models (LLMs) multimodales para trabajar con datos visuales y de texto, integración de datos y scripts en Python:</p><p><strong>1. Digitalización inicial</strong> — En primer lugar, se escanearon todos los exámenes escritos a mano. Este paso manual produjo ~70 archivos PDF (uno por examen) almacenados en un directorio raw/. El proceso tomó unos <em>60 minutos</em> para escanear y catalogar todos los documentos. Cada examen incluía en la cabecera el NIU (Número de Identificación Universitaria) del estudiante. <em>Se tardó más en escanear manualmente los examenes que en la corrección :)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*knXJ62qALktz0LBwspsSNA.png" /><figcaption>Fig. 3: La primera fase incluye el escaneo de todos los exámenes escritos a mano. Este paso manual produjo ~70 archivos PDF (uno por examen) almacenados en un directorio raw/. El proceso tomó unos <em>60 minutos</em> para escanear y catalogar todos los documentos. Cada examen incluía en la cabecera el NIU (Número de Identificación Universitaria) del estudiante.</figcaption></figure><p><strong>2. Clasificación por estudiante</strong> — Una vez en formato digital, entra ya en juego la IA. Se desarrolló un script Python que utiliza el modelo multimodal <strong>GPT-4.1 Vision</strong> de OpenAI para <strong>leer la primera página de cada PDF</strong> e identificar el NIU escrito (de forma manuscrita). Mediante un prompt diseñado específicamente, GPT-4.1 busca en la imagen un número de 7 dígitos (formato del NIU) y lo extrae. Por ejemplo, el prompt instruye: <em>“Localiza el NIU de 7 dígitos; puede aparecer en cualquier lugar, quizá etiquetado como ‘NIU:’ o solo, incluso con escritura débil. Devuelve únicamente los 7 dígitos o ‘NO_NIU_FOUND’ si no lo encuentras.”</em>. Gracias a esta clasificación automatizada, el sistema <strong>renombra cada PDF</strong> de examen a input_scans/&lt;NIU&gt;.pdf, asociando así cada conjunto de páginas al estudiante correcto. En esta fase se aprovechó la capacidad de GPT-4.1 para analizar imágenes (vision) incluyendo números escritos a mano.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GpWdD_IMF4Wy8N0iFwkBYQ.png" /><figcaption>Fig. 4: La imagen quiere mostrar el potencial de estos modelos LLM para la extracción de texto de respuestas en las que la escritura manuscrita resulta difícil de interpretar para el ojo humano.</figcaption></figure><p><strong>2. Extracción de respuestas</strong> — El siguiente paso del pipeline convierte el examen de cada estudiante en <strong>texto raw estructurado</strong>. Para ello, cada página del PDF se pasó por GPT-4.1 Vision de nuevo, pero esta vez con la tarea de <strong>leer todo el contenido escrito</strong> (preguntas y respuestas) y transcribirlo en formato texto. A diferencia de un OCR tradicional, aquí se pudo integrar directamente con la siguiente subtarea: extraer solo las respuestas del alumno. Mediante un prompt específico, el modelo GPT-4o analiza el texto resultante y <strong>localiza la respuesta del estudiante para cada pregunta</strong>, ignorando enunciados u otros textos. El prompt le indica que devuelva un JSON con un objeto &quot;answers&quot; donde las claves son los números de pregunta y los valores el texto de la respuesta dada por el alumno. Por ejemplo, si un estudiante dejó una pregunta en blanco, el valor sería cadena vacía. De este modo, cada examen manuscrito queda convertido en una <strong>estructura JSON</strong> clara con las respuestas del alumno, facilitando su evaluación automática en el siguiente paso. A modo ilustrativo, el esquema del prompt de extracción era así:</p><pre>{<br>  &quot;answers&quot;: {<br>    &quot;1&quot;: &quot;&lt;respuesta del estudiante a la pregunta 1&gt;&quot;,<br>    &quot;2&quot;: &quot;&lt;respuesta del estudiante a la pregunta 2&gt;&quot;,<br>    &quot;...&quot;: &quot;...&quot;<br>  }<br>}</pre><p>Este JSON intermedio (almacenado en temp_text/) contiene solo las respuestas del alumno, lo que aísla la información relevante para ser puntuada.</p><p><strong>3. Corrección con rúbricas mediante LLM</strong> — Llegamos al <strong>core </strong>del pipeline: la corrección automática de cada respuesta usando IA. Para las <strong>preguntas teóricas de desarrollo</strong>, se definió una <strong>rúbrica detallada</strong> con criterios de evaluación y se dispuso una <strong>respuesta modelo de referencia</strong> para cada ítem. En el caso de ATS (tema: MongoDB), la rúbrica incluía criterios como <em>claridad</em>, <em>justificación</em> y <em>conocimiento</em>, cada uno con un puntaje máximo asignado (3, 3 y 4 puntos respectivamente, total 10 puntos por pregunta). Además, las preguntas de tipo test o respuesta cerrada se valoraban automáticamente (1 punto cada acierto, peso 30% del total) y las preguntas prácticas de <em>queries</em> MongoDB se calificaban sobre 5 puntos cada una (peso 30%). Todo esto se configuró en un archivo YAML de <em>settings</em>, por ejemplo:</p><pre>scoring:<br>  mcq:                   # Preguntas tipo test<br>    points_per_correct_answer: 1<br>    weight: 0.3          # 30% de la nota<br>  development:           # Preguntas de desarrollo (teoría)<br>    max_points_per_question: 10<br>    criteria:<br>      - name: &quot;claridad&quot;<br>        max_points: 3<br>      - name: &quot;justificación&quot;<br>        max_points: 3<br>      - name: &quot;conocimiento&quot;<br>        max_points: 4<br>    weight: 0.4          # 40% de la nota<br>  mongo_queries:         # Preguntas prácticas de MongoDB<br>    max_points_per_query: 5<br>    weight: 0.3          # 30% de la nota</pre><p>Con esta rúbrica y las <strong>respuestas de referencia</strong> preparadas por el profesor, el sistema utiliza GPT-4o para <strong>evaluar cada respuesta del alumno</strong>. Para garantizar consistencia y facilidad de procesamiento, se aprovechó la función de <a href="https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses"><strong><em>Structured Output</em></strong></a> de OpenAI, la cual permite que el LLM genere directamente un <strong>JSON con la evaluación en base a un esquema predefinido de datos</strong>. En esencia, se le indica al modelo que compare la respuesta del estudiante con la solución esperada, que aplique los criterios de la rúbrica y devuelva un JSON estructurado con la puntuación y comentarios para cada criterio. GPT-4o sigue instrucciones deterministas (se fijó temperature: 0.0 para evitar variabilidad) y produce un resultado uniforme. Esta sería el prompt si se utilizara directamente: <em>&quot;Analiza la respuesta del alumno a la pregunta X comparándola con la respuesta correcta proporcionada. Asigna una puntuación en cada criterio (claridad, justificación, conocimiento) y genera un breve </em><strong><em>feedback</em></strong><em> indicando fortalezas y debilidades de la respuesta. Devuelve el resultado en JSON con el siguiente formato: </em><em>{ &quot;score&quot;: ..., &quot;max_points&quot;: ..., &quot;feedback&quot;: &quot;...&quot;, &quot;strengths&quot;: [...], &quot;weaknesses&quot;: [...] }.&quot;</em> En la práctica la funcionalidad <em>Structured Output</em> funciona así:</p><pre># Pydantic models for schema definitions<br>class EvaluationFeedback(BaseModel):<br>    score: float = Field(description=&quot;Numerical score for the answer&quot;)<br>    feedback: str = Field(description=&quot;General feedback on the answer&quot;)<br>    strengths: List[str] = Field(description=&quot;List of strengths in the answer&quot;)<br>    weaknesses: List[str] = Field(description=&quot;List of weaknesses in the answer&quot;)<br><br><br># Call OpenAI API with structured output schema<br>result = structured_chat_api(<br>    prompt_template=&quot;evaluate_theory_development&quot;,<br>    template_vars=template_vars,<br>    output_schema=EvaluationFeedback<br>)<br><br># Convert Pydantic model to dict for storage<br>feedback_dict = result.model_dump()</pre><p>Gracias a esta técnica, cada pregunta abierta se califica de forma transparente y con feedback detallado. OpenAI GPT-4o permite fijar un <strong>esquema JSON</strong> exacto para la salida, lo que facilita luego compilar automáticamente las notas.</p><p>Como ejemplo, <strong>para una pregunta teórica</strong>, la IA generó una evaluación JSON como esta (extracto real de la fase 4):</p><pre>&quot;score&quot;: 0.3,<br>&quot;max_points&quot;: 1.0,<br>&quot;feedback&quot;: &quot;La respuesta del estudiante muestra una comprensión básica de la relación entre usuarios y comentarios, pero no aborda adecuadamente el concepto de *sharding* en MongoDB. La propuesta de usar un esquema de referencia y la mención de claves de fragmentación por región o comentario más reciente no son adecuadas para el problema planteado, que requiere una estrategia de *sharding* efectiva para manejar millones de usuarios y comentarios.&quot;,<br>&quot;strengths&quot;: [<br>  &quot;El estudiante reconoce la relación entre usuarios y comentarios.&quot;,<br>  &quot;Muestra interés en la organización de datos mediante esquemas de referencia.&quot;<br>],<br>&quot;weaknesses&quot;: [<br>  &quot;No se aborda el concepto de sharding de manera adecuada.&quot;,<br>  &quot;Falta una justificación clara sobre la elección de la clave de partición.&quot;,<br>  &quot;La propuesta de usar claves de fragmentación por región o comentario más reciente no es adecuada para el problema planteado.&quot;<br>]</pre><p>En este caso, la pregunta pedía una estrategia de partición en MongoDB; la IA identificó que la respuesta del alumno era insuficiente, puntuó muy bajo (<em>score</em> 0.3 sobre 1.0 posible) y generó un <strong>feedback</strong> (por ahora interno) señalando qué entendió bien el estudiante (fortalezas) y qué no (debilidades). Obsérvese que el feedback es <strong>personalizado y específico</strong>, algo prácticamente inviable de proporcionar a mano a tantos alumnos. Toda esta información se guarda en estructuras JSON (denominadas <em>artefactos</em> de evaluación) por pregunta y por alumno que luego se utilizaran para la generación del informe final.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yT9DZDfEiVZSmkaTkE9Duw.png" /><figcaption>Fig. 5: ¿Cómo evaluar código que puede tener errores de sintaxis pero usa una lógica correcta?</figcaption></figure><p><strong>4. Evaluación de la parte práctica (código)</strong> — Además de preguntas teóricas, el examen de ATS incluía <strong>consultas prácticas en MongoDB</strong>. Para corregirlas, el pipeline combinó evaluación automática y IA para el análisis semántico del código. Primero, las consultas escritas por el estudiante se <strong>ejecutan en una instancia de MongoDB en </strong><a href="https://www.mongodb.com/products/platform/atlas-database"><strong>MongoDB Atlas</strong></a><strong> </strong>para comprobar si son sintácticamente correctas y si arrojan el resultado esperado (<em>test cases</em> definidos por el profesor). Este paso se integra en el script, marcando cada query como <em>executed_successfully</em> <em>true/false</em> y asignando un puntaje de validación (p. ej. 10/10 si pasó todos los tests). Luego, <strong>GPT-4o</strong> entra de nuevo para analizar la solución del alumno y <strong>generar feedback sobre el código</strong>, especialmente cuando la solución es parcialmente correcta. La IA puede detectar, por ejemplo, si la query olvida proyectar ciertos campos, o si es correcta pero ineficiente, etc., proporcionando sugerencias de mejora. En los <em>artefactos JSON</em> finales, por cada query se almacenan campos como &quot;validation_result&quot;: &quot;Passed/Failed&quot;, &quot;validation_score&quot;: X y un objeto &quot;ai_feedback&quot; con <em>feedback</em>, <em>suggestions</em>, <em>conceptos demostrados</em> y <em>conceptos ausentes</em>. Esta combinación permite puntuar objetivamente las prácticas (vía tests unitarios) y a la vez ofrecer al estudiante <strong>comentarios cualitativos</strong> sobre su código. De nuevo, todo queda estructurado en JSON para su posterior consulta.</p><pre>{<br>&quot;niu&quot;: &quot;XXXXXXX&quot;,<br>&quot;queries&quot;: [<br>  {<br>    &quot;query_number&quot;: 1,<br>    &quot;query_text&quot;: &quot;db.restaurants.find({\&quot;type_of_food\&quot;: \&quot;Chinese\&quot;, \&quot;address line 2\&quot;: \&quot;Cardiff\&quot;})&quot;,<br>    &quot;expected_description&quot;: &quot;Find Chinese restaurants in Cardiff, project name&quot;,<br>    &quot;executed_successfully&quot;: true,<br>    &quot;error&quot;: null,<br>    &quot;validation_result&quot;: &quot;Passed validation&quot;,<br>    &quot;validation_score&quot;: 10,<br>    &quot;ai_feedback&quot;: {<br>    &quot;score&quot;: 7,<br>    &quot;feedback&quot;: &quot;The query correctly filters for Chinese restaurants in Cardiff but does not project the required<br>    fields.&quot;,<br>    &quot;improvement_suggestions&quot;: [<br>    &quot;Include a projection to return only the &#39;name&#39; field and exclude &#39;_id&#39;.&quot;,<br>    &quot;Ensure the query structure includes both filtering and projection for complete results.&quot;<br>    ],<br>    &quot;key_concepts_demonstrated&quot;: [<br>    &quot;Filtering documents using field-value pairs&quot;<br>    ],<br>    &quot;key_concepts_missing&quot;: [<br>    &quot;Projection of specific fields&quot;<br>    ]<br>    ...</pre><p><strong>5. Generación de informes y visualización</strong> — Finalmente, el pipeline agrega los resultados por estudiante y de la clase en general. Por un lado, se genera <strong>un informe PDF personalizado</strong> para cada alumno, que incluye su nota desglosada por partes (test, teoría, prácticas) y todos los comentarios o feedback generado por la IA en cada pregunta. Por otro lado, se alimenta un <strong>portal web</strong> (<em>dashboard</em>) para el profesor con <strong>estadísticas globales</strong>: distribución de notas, promedio por pregunta, <em>insights</em> de errores más comunes, conceptos peor entendidos, etc. El <em>Portal del Estudiant</em> desarrollado muestra gráficamente qué preguntas tuvieron menor tasa de acierto, cuáles criterios de la rúbrica recibieron puntuaciones más bajas en general, etc., proporcionando al docente una <strong>visión panorámica de la clase</strong> que antes era imposible obtener.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R2dnKEdp0hdzN5v1sgOT_g.png" /><figcaption><em>Fig. 6: Diapositiva </em><strong><em>“Portal de l’Estudiant”</em></strong><em> que ilustra la generación automatizada de dashboards de la clase y un informe PDF individual por estudiante a partir de los artefactos de corrección. Los profesores pueden ver de un vistazo las estadísticas globales, errores frecuentes y conceptos menos comprendidos en el examen.</em></figcaption></figure><p>Todos estos pasos se orquestan mediante scripts de Python que automatizan el flujo de datos de un directorio a otro (raw → input_scans → temp_text → artefacts → results). El resultado es un <strong>pipeline modular</strong>: se podrían ajustar las rúbricas o preguntas para otros exámenes y volver a ejecutar el proceso con mínimos cambios. En el caso estudiado, <strong>70 exámenes</strong> de ATS fueron procesados completamente en <strong>20 minutos</strong>, obteniendo <strong>evaluaciones coherentes y un conjunto de feedback de valor </strong>para cada estudiante, algo inviable manualmente en tan poco tiempo.</p><p>En los siguientes enlaces puedes ver el proceso en diferentes posts que se compartieron via LinkedIn:</p><ul><li><a href="https://www.linkedin.com/posts/albertgilopez_hoy-he-enviado-las-notas-del-examen-de-mongodb-activity-7327619009841905664-Qrdb/?utm_source=share&amp;utm_medium=member_desktop&amp;rcm=ACoAABRP1HgBhWL4HAMF0Zmss10T0nQ8JzxSxNM">https://www.linkedin.com/posts/albertgilopez_hoy-he-enviado-las-notas-del-examen-de-mongodb-activity-7327619009841905664-Qrdb/?utm_source=share&amp;utm_medium=member_desktop&amp;rcm=ACoAABRP1HgBhWL4HAMF0Zmss10T0nQ8JzxSxNM</a></li><li><a href="https://www.linkedin.com/posts/albertgilopez_enginyeriauab-activity-7330472379040661507-4Qdt/?utm_source=share&amp;utm_medium=member_desktop&amp;rcm=ACoAABRP1HgBhWL4HAMF0Zmss10T0nQ8JzxSxNM">https://www.linkedin.com/posts/albertgilopez_enginyeriauab-activity-7330472379040661507-4Qdt/?utm_source=share&amp;utm_medium=member_desktop&amp;rcm=ACoAABRP1HgBhWL4HAMF0Zmss10T0nQ8JzxSxNM</a></li><li><a href="https://www.linkedin.com/posts/albertgilopez_enginyeriauab-activity-7333009101544648705-BG05/?utm_source=share&amp;utm_medium=member_desktop&amp;rcm=ACoAABRP1HgBhWL4HAMF0Zmss10T0nQ8JzxSxNM">https://www.linkedin.com/posts/albertgilopez_enginyeriauab-activity-7333009101544648705-BG05/?utm_source=share&amp;utm_medium=member_desktop&amp;rcm=ACoAABRP1HgBhWL4HAMF0Zmss10T0nQ8JzxSxNM</a></li><li><a href="https://www.linkedin.com/posts/albertgilopez_enginyeriauab-activity-7335545814607409153-KIo7/?utm_source=share&amp;utm_medium=member_desktop&amp;rcm=ACoAABRP1HgBhWL4HAMF0Zmss10T0nQ8JzxSxNM">https://www.linkedin.com/posts/albertgilopez_enginyeriauab-activity-7335545814607409153-KIo7/?utm_source=share&amp;utm_medium=member_desktop&amp;rcm=ACoAABRP1HgBhWL4HAMF0Zmss10T0nQ8JzxSxNM</a></li></ul><h3>Conclusiones</h3><p>La experiencia con este proyecto piloto demuestra que la <strong>IA puede acelerar drásticamente la corrección</strong> de exámenes, a la vez que <strong>mejora la calidad del feedback</strong>. En el caso de ATS, el profesor pasó de dedicar fines de semana corrigiendo a recibir un resumen detallado del rendimiento de toda su clase en poco tiempo. Los estudiantes, por su parte, obtuvieron <strong>comentarios personalizados</strong> sobre sus respuestas, incluso señalando fortalezas y debilidades específicas, que els ayuda a comprender mejor sus errores y aciertos.</p><p>Para el profesorado, les libera tiempo de las tareas más artesanas, <strong>la IA se encarga del ~80% del trabajo</strong>, permitiendo al docente enfocarse en el <strong>20% que aporta valor</strong>: diseñar mejores actividades, reflexionar sobre cómo mejorar la enseñanza de los conceptos donde muchos fallaron, o tutorizar a alumnos con dificultades. Además, la uniformidad de la evaluación hace más <strong>justa y consistente </strong>las calificaciones, reduciendo el sesgo humano y los errores por cansancio.</p><p>Por supuesto, este pipeline no pretende <em>reemplazar</em> al profesor <em>(siempre y cuando no cambie y se mantenga el rol tal y como es ahora). </em>Por ahora, el docente sigue al mando: debe <strong>calibrar las rúbricas</strong> adecuadamente, proporcionar buenas respuestas modelo y revisar los casos límite donde la IA pueda fallar (por ejemplo, respuestas ambiguas o creativas que el modelo no sepa valorar). De hecho, el sistema facilita esta revisión: el profesor puede filtrar fácilmente aquellas preguntas donde, por ejemplo, la IA dio puntuaciones muy bajas o tuvo baja confianza, y revisar manualmente solo esas, en lugar de todos los exámenes.</p><p>En cuanto a <strong>escalabilidad</strong>, la solución es prometedora. Una vez afinado, se podría extender a otras asignaturas, simplemente actualizando las rúbricas y <em>prompts</em> para el nuevo dominio. También se podría integrar con las plataformas de campus virtual actuales para volcar automáticamente las notas o generar visualizaciones para coordinadores de titulación, etc. Las posibilidades son infinitas. En resumen, <strong>se ha transformado la corrección de un examen en una oportunidad de análisis pedagógico</strong>: la evaluación deja de ser un cuello de botella y se convierte en una fuente de datos que permite tomar mejores decisiones.</p><p><em>Me gustaría agradecer a Carlos Borrego y al equipo de Dirección la Escuela de Ingenieria de la UAB por la oganizacion de esa jornada. Estos encuentros para repensar la docencia universitaria en tiempo de cambio, en tiempo de IA, son necesarios.</em></p><h3>What’s next</h3><p>Quedan aún <em>retos y mejoras</em> por explorar antes de ver estas herramientas de IA plenamente integradas en la docencia diaria. Un aspecto clave a futuro es incorporar la <strong>evaluación automática de ejercicios prácticos complejos</strong>, como problemas de programación o laboratorio. Si bien en ATS se corrigieron consultas de bases de datos, sería interesante integrar sistemas de <em>auto-grading</em> de código fuente (con suites de pruebas unitarias, evaluación de estilo, etc.) para asignaturas de programación, conectándolos también con LLMs que generen feedback cualitativo al estudiante.</p><p>Otro frente importante es garantizar la <strong>trazabilidad y transparencia</strong> del proceso. Dado que estos sistemas de corrección con IA serían considerados de <em>alto riesgo</em> bajo el AI Act, deberán implementar registros detallados de cada decisión de la IA, <strong>historias de cambios, y mecanismos de supervisión humana</strong>. Por ejemplo, conservar un log de los <em>prompts</em> y respuestas del modelo por si se requiere una auditoría, o facilitar que el profesor ajuste una calificación si detecta un error en la corrección automática, quedando registrada dicha intervención. Esto se alinea con desarrollar la herramienta conforme a los <strong>marcos éticos y normativos</strong> vigentes, asegurando que sea <em>justa, explicable y respetuosa</em> con la evaluación de los estudiantes.</p><p>Desde el punto de vista institucional, será necesario también dialogar sobre <strong>aceptación y formación</strong>. Los docentes deben entender estos sistemas, confiar en ellos y saber usarlos (por ejemplo, diseñando buenas rúbricas y <em>prompts</em>). Probablemente surgirá la figura de “metaevaluador”, un profesor especialista en calibrar y supervisar a la IA que corrige. Asimismo, habría que adaptar las guías docentes y normativas internas para reflejar cómo se usa la IA en la evaluación (similar a cuando se introdujeron los tests tipo <em>scanner</em> o plataformas anti-plagio).</p><p>En cuanto a desarrollo, el próximo curso exploraremos las capacidades del pipeline a nuevos escenarios. También exploraremos la integración de <strong>agentes de IA </strong>utilizando frameworks más amplios de orquestación de LLMs, como LangGraph, para habilitar flujos de trabajo condicionales más sofisticados. Puedes leer un poco más acerca de ello en los siguientes artículos:</p><ul><li><a href="https://medium.com/@jddam/gu%C3%ADa-completa-langgraph-y-el-futuro-de-los-agentes-de-ia-en-2025-2f34ceaa456f"><strong>[GUÍA COMPLETA] LangGraph y el futuro de los Agentes de IA en 2025</strong></a></li><li><a href="https://medium.com/@jddam/think-digital-summit-2024-ai-agentic-y-dise%C3%B1o-de-sistemas-multi-agente-dcbcd00cdf03"><strong>Think Digital Summit 2024: AI Agentic y diseño de sistemas multi-agente</strong></a></li></ul><p>En definitiva, la intersección de <strong>IA y educación</strong> apenas está comenzando. Experimentos pioneros como este pipeline que hicimos en la UAB muestran un camino posible hacia correcciones más <strong>rápidas, personalizadas y basadas en datos</strong>. Queda abierta la invitación a <strong>colaborar, aportar ideas y discutir</strong> sobre estas herramientas: cómo mejorarlas, cómo incorporarlas responsablemente y cómo asegurar que realmente apoyen al aprendizaje.</p><p><strong>Comparte tu experiencia:</strong></p><p>Estoy abierto a colaborar y discutir sobre las posibilidades que ofrece la inteligencia artificial y cómo trabajar juntos para explorar y construir soluciones en diferentes sectores. Si tienes ideas, preguntas o simplemente quieres hablar de ello, escríbeme:</p><ul><li>GitHub: <a href="https://github.com/albertgilopez">https://github.com/albertgilopez</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/albertgilopez/">https://www.linkedin.com/in/albertgilopez/</a></li><li>M.IA, tu asistente financiero inteligente: <a href="https://himia.app/">https://himia.app/</a></li><li>Inteligencia Artificial Generativa en español: <a href="https://www.codigollm.es/">https://www.codigollm.es/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a35a8d72331" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cómo conectar Odoo con agentes de IA usando Model Context Protocol (MCP) y LangGraph (paso a paso)]]></title>
            <link>https://medium.com/@jddam/c%C3%B3mo-conectar-odoo-con-agentes-de-ia-usando-model-context-protocol-mcp-y-langgraph-paso-a-paso-65096c36787d?source=rss-3723dc84302b------2</link>
            <guid isPermaLink="false">https://medium.com/p/65096c36787d</guid>
            <category><![CDATA[langgraph]]></category>
            <category><![CDATA[odoo]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[model-context-protocol]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Albert Gil López]]></dc:creator>
            <pubDate>Thu, 01 May 2025 20:26:00 GMT</pubDate>
            <atom:updated>2025-08-28T17:53:49.293Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DBnQ1c_BJ2xXr_NfTTOn0w.png" /><figcaption>AUTOR: OpenAI Models</figcaption></figure><p>La integración de agentes IA con sistemas ERP como Odoo abre nuevas posibilidades de automatización contable. El repositorio <strong>MCP-Odoo</strong> (<a href="https://github.com/yourtechtribe/mcp-odoo-for-finance">https://github.com/yourtechtribe/mcp-odoo-for-finance</a>) implementa un puente entre Odoo y agentes LLM usando el <strong>Model Context Protocol (MCP)</strong>. Gracias a este <a href="https://www.anthropic.com/news/model-context-protocol#:~:text=The%20Model%20Context%20Protocol%20is,that%20connect%20to%20these%20servers">estándar abierto</a>, los agentes pueden acceder de forma estandarizada a datos de Odoo (clientes/proveedores, facturas, pagos, etc.), ejecutar acciones y realizar reconciliaciones contables​. En este artículo veremos cómo funciona internamente este conector, desde su arquitectura hasta ejemplos prácticos con LangGraph, además de su aplicación real en la startup M.IA para transformar la gestión de tesorería.</p><h3>Background</h3><p>MCP es un protocolo abierto impulsado por Anthropic (noviembre 2024) que <a href="https://docs.anthropic.com/en/docs/agents-and-tools/mcp#:~:text=MCP%20is%20an%20open%20protocol,different%20data%20sources%20and%20tools"><strong>“estandariza cómo las aplicaciones proveen contexto a los LLMs”</strong></a>​. Anthropic lo describe como <a href="https://docs.anthropic.com/en/docs/agents-and-tools/mcp#:~:text=MCP%20is%20an%20open%20protocol,different%20data%20sources%20and%20tools"><strong>“un puerto USB-C para aplicaciones de IA”</strong></a>: un conector único para vincular modelos con diferentes fuentes de datos y herramientas de forma segura​. La meta de MCP es unificar integraciones dispersas; por ejemplo, reemplazar conexiones ad-hoc con una arquitectura común donde los agentes hacen <em>tool calls</em> REST o SSE a servidores MCP para consultar o modificar datos.</p><p>Este enfoque encaja con la tendencia de frameworks de agentes emergentes. Por ejemplo:</p><ul><li><a href="https://github.com/openai/openai-agents-python#:~:text=The%20OpenAI%20Agents%20SDK%20is,well%20as%20100%2B%20other%20LLMs"><strong>OpenAI Agents SDK</strong></a>: un framework para orquestar flujos multiagente, agnóstico al proveedor de LLM​.</li><li><a href="https://www.firecrawl.dev/blog/best-open-source-agent-frameworks-2025#:~:text=Before%20we%20dive%20into%20our,needed%20for%20comprehensive%20data%20gathering"><strong>FireCrawl (FIRE-1)</strong></a>: un agente especializado en interacción web que permite la navegación automatizada en sitios complejos​, útil para extraer datos de portales financieros o web.</li><li><a href="https://www.langchain.com/langgraph#:~:text=Controllable%20cognitive%20architecture%20for%20any,task"><strong>LangGraph (LangChain)</strong></a>: una librería para definir arquitecturas multiagente complejas. Su <em>framework flexible soporta flujos de control diversos — agentes únicos, multiagentes, jerárquicos, secuenciales — y maneja escenarios realistas complejos</em>. LangGraph facilita el diseño detallado de cómo los agentes intercambian información y herramientas.</li><li><a href="https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/#:~:text=A2A%20is%20an%20open%20protocol,to%20build%20agents%20capable%20of"><strong>Protocolo A2A de Google</strong></a> (lanzado en 2025): un estándar abierto para colaboración entre agentes IA. A2A <strong>complementa MCP</strong>​, permitiendo que agentes diveros (incluso de distintos proveedores) se comuniquen, compartan datos y coordinen acciones de forma segura sobre plataformas empresariales. Según Google, A2A ofrece interoperabilidad universal y un método estándar para gestionar agentes en entornos multi-cloud.</li></ul><p>En conjunto, MCP, OpenAI Agents, FireCrawl, LangGraph y A2A son ejemplos de tecnologías que estan formando un ecosistema en crecimiento orientado a sistemas multiagente interoperables, donde MCP provee la capa de <strong>acceso a datos/fuentes externas</strong> mientras LangGraph/A2A permiten la <strong>orquestación y coordinación</strong> entre agentes.</p><h3>Hands-on: Integración de Model Context Protocol (MCP) con Odoo y Agentes IA usando LangGraph</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*21we-OI8IRNHVxSQoc-r_A.jpeg" /><figcaption>AUTOR: Mermaid</figcaption></figure><p>La implementación de <strong>MCP-Odoo</strong> se apoya en la librería <strong>FastMCP</strong> (versión ≥1.6.0). En el archivo principal se crea una instancia de servidor MCP y se registran herramientas que quedan expuestas para su uso. Por ejemplo:</p><pre>from fastmcp import FastMCP, Context<br><br># 1. Definición del servidor MCP<br>mcp = FastMCP(<br>    name=&quot;mcp-odoo&quot;,<br>    version=&quot;1.0.0&quot;,<br>    instructions=&quot;MCP server for Odoo accounting integration...&quot;<br>)<br><br># 2. Registro de herramientas (tools)<br>@mcp.tool()<br>async def odoo_version(ctx: Context) -&gt; str:<br>    &quot;&quot;&quot;Obtiene la versión del servidor Odoo.&quot;&quot;&quot;<br>    version = await ctx.app.odoo_client.get_server_version()<br>    return version</pre><p>En este fragmento, creamos FastMCP(name=&quot;mcp-odoo&quot;, version=&quot;1.0.0&quot;, ...) y usamos el decorador @mcp.tool() para exponer una función como herramienta MCP​. Cada herramienta define su esquema de petición/respuesta (argúmenos y return), que el agente entenderá automáticamente.</p><p>Además se gestiona el ciclo de vida de la aplicación usando un asynccontextmanager. Por ejemplo:</p><pre>from contextlib import asynccontextmanager<br><br>@asynccontextmanager<br>async def app_lifespan():<br>    # Conectar al inicio del servidor<br>    client = OdooClient(url, db, user, pwd)<br>    await client.connect()<br>    try:<br>        yield AppContext(odoo_client=client)<br>    finally:<br>        # Desconectar al finalizar<br>        await client.disconnect()</pre><p>Aquí OdooClient es una clase que administra la conexión XML-RPC a Odoo. Al iniciar el servidor MCP, conectamos automáticamente al ERP y guardamos el cliente en el contexto de la aplicación; al cerrarlo, lo desconectamos​. Esto permite que todas las herramientas (ctx.app.odoo_client) tengan acceso seguro a Odoo.</p><p>La configuración general se carga desde un archivo .env con las credenciales y URL de Odoo. Por ejemplo:</p><pre>ODOO_URL=https://mi-odoo.com<br>ODOO_DB=mi_base<br>ODOO_USERNAME=usuario<br>ODOO_PASSWORD=contraseña<br>HOST=0.0.0.0<br>PORT=8080</pre><p>Estas variables se usan al crear OdooClient​. Una vez definido el servidor y las herramientas, basta ejecutarlo: python -m mcp_odoo_public (transport por defecto SSE) o --transport stdio para pruebas locales. El README oficial detalla estos pasos y destaca las capacidades expuestas (p. ej. “access partner information, invoices, payments, perform reconciliation”)​.</p><p>Con el servidor MCP-Odoo en marcha, podemos integrarlo en un agente LangGraph. Usamos langchain-mcp-adapters y langgraph para ello. Por ejemplo:</p><pre>from langchain_mcp_adapters.client import MultiServerMCPClient<br>from langgraph.prebuilt import create_react_agent<br>from langchain_core.messages import HumanMessage<br>import asyncio, os<br><br>async def main():<br>    # 1. Configurar cliente MCP para el servidor Odoo<br>    mcp_servers = {<br>        &quot;odoo&quot;: {<br>            &quot;url&quot;: &quot;http://localhost:8080/sse&quot;,<br>            &quot;transport&quot;: &quot;sse&quot;,<br>        }<br>    }<br>    async with MultiServerMCPClient(mcp_servers) as client:<br>        # 2. Obtener las herramientas MCP disponibles<br>        tools = client.get_tools()<br>        print(f&quot;Herramientas MCP disponibles: {[t.name for t in tools]}&quot;)<br>        # 3. Crear un agente LangGraph con el modelo elegido y las herramientas<br>        model = &quot;openai:gpt-4&quot;  # o &quot;anthropic:claude-3...&quot;<br>        agent = create_react_agent(model, tools)<br>        # 4. Ejecutar una consulta<br>        response = await agent.ainvoke({<br>            &quot;messages&quot;: [HumanMessage(content=&quot;¿Qué versión de Odoo usamos?&quot;)]<br>        })<br>        print(response)<br>        <br>asyncio.run(main())</pre><p>Este código asíncrono ilustra el flujo básico: nos conectamos al servidor MCP-Odoo, recuperamos automáticamente todas las herramientas definidas, creamos un agente LangGraph (create_react_agent) con un modelo (GPT-4, Claude, etc.) y enviamos una consulta. LangGraph se encarga de invocar la(s) herramienta(s) necesaria(s) basada en la respuesta del LLM. En el ejemplo, el agente preguntaría por la versión de Odoo, el LLM decidiría llamar al método odoo_version(), y luego recogería y mostraría la respuesta. En la práctica, podemos pedir análisis financieros complejos: como muestra la <a href="https://github.com/yourtechtribe/model-context-protocol-mcp-odoo/blob/main/docs/index.md">guía avanzada</a> de MCP-Odoo, un agente LangGraph puede encadenar pasos (obtener versión, listar facturas de proveedores, conciliar pagos, etc.) para generar un informe contable​. Cada paso corresponde a herramientas definidas en el servidor MCP, lo que hace el sistema altamente modular.</p><h3>Conclusiones</h3><p>La integración MCP-Odoo ya tiene aplicación real. En nuestra startup <strong>M.IA</strong> (del grupo Your Tech Tribe) empleamos sistemas multiagente de IA para transformar la gestión de tesorería empresarial. Nuestro objetivo es desarrollar <em>“una plataforma IA multi-agente que revolucionará los flujos de trabajo financieros, liberando equipos de tareas repetitivas”</em>​ (<a href="https://www.himia.app/en/multi-system-ai-agents/#:~:text=Imagine%20an%20environment%20where%20artificial,making">himia.app</a>). En la práctica, combinamos múltiples agentes LLM especializados (conciliación, cierre contable, análisis) para formar <a href="https://www.telefonica.com/en/communication-room/press-room/wayra-strong-agenda-30-startups-4yfn-2025/"><em>“un equipo de asesores virtuales”</em></a> en finanzas​. El conector MCP-Odoo facilita esto al exponer los datos financieros de Odoo a esos agentes de forma estándar. Gracias a MCP y LangGraph, en M.IA puede automatizar tareas rutinarias (por ejemplo, conciliación de facturas y pagos) y dar recomendaciones en lenguaje natural, dejando que los equipos humanos se enfoquen en decisiones estratégicas​.</p><p>En resumen, MCP-Odoo provee una capa técnica que conecta las bases de datos ERP con la inteligencia generativa, habilitando casos de uso como informes contables bajo demanda, explicación de saldos o auditoría asistida por IA.</p><h3>What’s Next</h3><p>Las posibilidades futuras son amplias:</p><ul><li><strong>Conectar más ERP/CRM</strong>: Extender el enfoque a otros sistemas (por ejemplo SAP, Microsoft Dynamics, Salesforce, etc.) usando adaptadores MCP permite centralizar datos de múltiples fuentes.</li><li><strong>Arquitecturas multiagente avanzadas</strong>: Emplear frameworks como <a href="https://www.langchain.com/langgraph#:~:text=Controllable%20cognitive%20architecture%20for%20any,task">LangGraph</a>​ para diseñar flujos de trabajo complejos con varios agentes especializados (p.ej. uno de cobro, otro de pagos, otro de análisis predictivo). Se pueden crear arquitecturas jerárquicas o supervisoras donde agentes colaboran o se supervisan entre sí.</li><li><strong>Capas de coordinación con A2A</strong>: Explorar el protocolo <a href="https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/#:~:text=A2A%20is%20an%20open%20protocol,to%20build%20agents%20capable%20of">Agent2Agent (A2A)</a> de Google​ para que agentes de distintos proveedores cooperen de forma segura. A2A ofrece un estándar para comunicación seguro entre agentes cliente y remoto, lo que facilitaría escenarios donde, por ejemplo, un agente financiero coordinara tareas con un agente bancario o un agente CRM sin compartir datos confidenciales directamente.</li></ul><p>En conjunto, el uso de MCP en Odoo es solo un inicio. En el futuro podemos imaginar un ecosistema multiagente plenamente interoperable: agentes IA que conversan y actúan sobre varios ERP/CRM, coordinados por frameworks como LangGraph o protocolos como A2A, creando nuevas capas inteligentes de automatización empresarial.</p><p>Si quieres seguir explorando este tema, te recomiendo:</p><ul><li><a href="https://github.com/yourtechtribe/mcp-odoo-for-finance"><strong>Repositorio GitHub MCP-Odoo</strong></a></li><li><a href="https://www.anthropic.com/news/model-context-protocol"><strong>Introducing the Model Context Protocol</strong></a></li><li><a href="https://medium.com/@jddam/gu%C3%ADa-completa-langgraph-y-el-futuro-de-los-agentes-de-ia-en-2025-2f34ceaa456f"><strong>GUÍA COMPLETA: LangGraph y el futuro de los Agentes de IA en 2025</strong></a></li></ul><p><strong>Comparte tu experiencia:</strong></p><p>Estoy abierto a colaborar y discutir sobre las posibilidades que ofrece la inteligencia artificial y cómo trabajar juntos para explorar y construir soluciones en diferentes sectores. Si tienes ideas, preguntas o simplemente quieres hablar de ello, escríbeme:</p><ul><li><strong>GitHub:</strong> <a href="https://github.com/albertgilopez">https://github.com/albertgilopez</a></li><li><strong>LinkedIn:</strong> <a href="https://www.linkedin.com/in/albertgilopez/">https://www.linkedin.com/in/albertgilopez/</a></li><li><strong>M.IA, tu asistente financiero inteligente:</strong> <a href="https://himia.app/">https://himia.app/</a></li><li><strong>Inteligencia Artificial Generativa en español:</strong> <a href="https://www.codigollm.es/">https://www.codigollm.es/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65096c36787d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Crea tu propio agente Deep Research con el nuevo SDK Agents de OpenAI y FireCrawl (local)]]></title>
            <link>https://medium.com/@jddam/crea-tu-propio-agente-deepresearch-con-el-nuevo-sdk-agents-de-openai-y-firecrawl-local-9a05e64539ac?source=rss-3723dc84302b------2</link>
            <guid isPermaLink="false">https://medium.com/p/9a05e64539ac</guid>
            <category><![CDATA[deep-research]]></category>
            <category><![CDATA[agentic-mesh]]></category>
            <category><![CDATA[agents]]></category>
            <category><![CDATA[openai]]></category>
            <category><![CDATA[firecrawl]]></category>
            <dc:creator><![CDATA[Albert Gil López]]></dc:creator>
            <pubDate>Fri, 14 Mar 2025 06:18:09 GMT</pubDate>
            <atom:updated>2025-03-14T09:00:35.666Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PJE-YIEGXcZZsN_ANw1v7g.png" /><figcaption>AUTOR: OpenAI</figcaption></figure><p>Hace poco más de un mes, OpenAI <a href="https://openai.com/index/introducing-deep-research/">anunció</a> una nueva funcionalidad llamada Deep Research, un agente (el primero de OpenAI) que usa el razonamiento (introducido también en los <a href="https://openai.com/o1/">modelos o1/o3</a>) para sintetizar grandes cantidades de información y completar tareas de investigación en varios pasos.</p><p>Realizar investigaciones profundas y en detalle de manera automatizada es fundamental hoy en día. Estas tareas, que antes podían durar semanas, ahora se pueden completar en menos de 15 minutos. Acceder a información actualizada de manera rápida para tomar decisiones, es clave, pero también es una tarea compleja.</p><p>La llegada del nuevo SDK de agentes de OpenAI abre una nueva oportunidad para crear agentes de IA capaces de automatizar estas tareas. Sin embargo, limitarse únicamente al ecosistema cerrado de OpenAI puede ser una restricción significativa, especialmente si valoras la independencia tecnológica y la flexibilidad. Otras soluciones como <a href="https://www.crewai.com/">CrewAI</a>, <a href="https://www.langchain.com/langgraph">LangGraph</a>, e incluso herramientas como <a href="https://tavily.com/">Tavily</a>, pueden ser útiles para crear sistemas similares sin depender únicamente de un proveedor, algo que mencionaba en mi último post de <a href="https://www.linkedin.com/posts/albertgilopez_new-tools-for-building-agents-activity-7305845097336627201-rdB7?utm_source=share&amp;utm_medium=member_desktop&amp;rcm=ACoAABRP1HgBhWL4HAMF0Zmss10T0nQ8JzxSxNM">LinkedIn</a>.</p><p>En este artículo te explico cómo superar esta limitación combinando el nuevo SDK de OpenAI Agents con FireCrawl, una herramienta que permite realizar búsquedas y conectar los LLMs a la web , y que puede ejecutarse tanto en local mediante Docker como en la nube usando su propia API. El objetivo es desarrollar un agente de IA capaz de recopilar información actualizada, sintetizar los resultados y ofrecer respuestas claras y referenciar las fuentes de información.</p><h3>Background: ¿Por qué apostar por el nuevo SDK de OpenAI Agents y FireCrawl?</h3><p>En el informe <a href="https://cloud.google.com/startup/resources?hl=en">“Google Cloud Future of AI”</a> una de las predicciones de las que se habla es que los <em>foundational models </em>no cambiarán mucho en los próximos 18 meses. Eso deja espacio para que startups como <a href="https://www.himia.app/">M.IA</a> 🐙 podamos desarrollar soluciones especializadas con un retorno de inversión claro.</p><p>La solución que vamos a implementar es posible realizarla utilizando otros frameworks como LangGraph y CrewAI. No obstante, el objetivo de este artículo es también probar el nuevo SDK de OpenAI Agents y evaluar la apuesta estratégica que está haciendo OpenAI por posicionarse en la capa de negocio de los frameworks.</p><p>El SDK presenta ciertas limitaciones especialmente en aspectos críticos como la persistencia del estado (como alternativa usar LangGraph) y la monitorización de las interacciones (la monitorización es cerrada ya que tienes que uitlizar la propia plataforma de OpenAI, similar a LangChain vs LangSmith). Además, tal y como mencionaba en el post de <a href="https://www.linkedin.com/posts/albertgilopez_new-tools-for-building-agents-activity-7305845097336627201-rdB7/">LinkedIn</a>, apostar todo a OpenAI puede generar un problema de dependencia tecnológica importante.</p><p>Precisamente para mitigar estas limitaciones, he decidido combinar OpenAI Agents con herramientas externas como FireCrawl, que permite realizar búsquedas web avanzadas y estructuradas. FireCrawl no solo es flexible por ofrecer una versión en local utilizando Docker, sino que también dispone de una API para escalar rápido según las necesidades del proyecto.</p><p>La combinación de utilizar otras herramientas, como Firecrawl, para desarrollar este agente de IA DeepResearch es un ejemplo que aprovecha al máximo las ventajas del nuevo SDK de OpenAI, pero sin renunciar a la independencia tecnológica y la posibilidad de integrar fácilmente otras herramientas y servicios externos en el futuro.</p><h3>Hands On: Crea tu propio agente DeepResearch con el nuevo SDK Agents de OpenAI y FireCrawl (local)</h3><p>Para construir el agente DeepResearch, combinando el nuevo S<a href="https://platform.openai.com/docs/guides/agents-sdk">DK de OpenAI Agents</a> con <a href="https://www.firecrawl.dev/">FireCrawl</a>, la arquitectura se organiza alrededor de tres agentes principales que trabajan de manera colaborativa para ofrecer respuestas completas y precisas. La división clara de responsabilidades entre estos agentes simplifica la lógica del sistema y facilita su escalabilidad.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hc4ZStmqerbostEJlMGd3w.jpeg" /><figcaption>AUTOR: Albert Gil López</figcaption></figure><h4>1. Planner Agent (Agente para Planificación)</h4><p>Este agente recibe la pregunta inicial del usuario, la analiza y genera un plan estructurado, incluyendo consultas específicas que utilizará el siguiente agente para buscar información. A continuación se muestra cómo se define usando el <a href="https://platform.openai.com/docs/guides/agents-sdk">SDK de OpenAI Agents</a>:</p><pre>planner_agent = Agent(<br>    name=&quot;Planner&quot;,<br>    instructions=&quot;&quot;&quot;Analiza la pregunta del usuario, desglósala en consultas específicas y genera un plan detallado de búsqueda.&quot;&quot;&quot;,<br>    tools=[generate_search_queries],<br>    model=&quot;gpt-4o&quot;,<br>)</pre><p>La función generate_search_queries puede ser algo tan sencillo como esto:</p><pre>@function_tool()<br>async def generate_search_queries(topic: str, num_queries: int = 3) -&gt; List[str]:<br>    return [f&quot;{topic} aspectos clave&quot;, f&quot;{topic} últimas novedades&quot;, f&quot;{topic} ejemplos prácticos&quot;]</pre><h4>2. Researcher Agent (Agente para Investigación)</h4><p>Este agente es crucial en la arquitectura, ya que realiza búsquedas web mediante <a href="https://www.firecrawl.dev/">FireCrawl</a> para recolectar la información necesaria. El uso de FireCrawl es especialmente relevante porque facilita realizar búsquedas estructuradas tanto en local (usando Docker) como en la nube.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xDXxySmk7ElGQCdCPZv-OQ.png" /><figcaption>AUTOR: Firecrawl</figcaption></figure><p>Aquí tienes cómo implementar una búsqueda básica con FireCrawl:</p><pre>@function_tool()<br>async def search_web(query: str, num_results: Optional[int] = 5) -&gt; str:<br>    results = self.extractor.search_and_extract(<br>        query=query,<br>        limit=num_results,<br>        formats=[&quot;markdown&quot;]<br>    )<br>    formatted_results = &quot;&quot;<br>    for result in results:<br>        url = result.get(&quot;search_metadata&quot;, {}).get(&quot;url&quot;, &quot;URL desconocida&quot;)<br>        content = result.get(&quot;markdown&quot;, &quot;Sin contenido&quot;)[:2000] + &quot;...[contenido truncado]&quot;<br>        formatted_results += f&quot;## Fuente: {url}\n{content}\n\n&quot;<br>    return formatted_results</pre><p>Además, FireCrawl permite extraer contenido directamente de URLs específicas, lo que facilita profundizar rápidamente en temas concretos:</p><pre>@function_tool()<br>async def extract_from_url(/service/url: str) -&gt; str:<br>    result = self.extractor.extract_from_url(https://medium.com/%3Cbr%3E%20%20%20%20%20%20%20%20url=url,%3Cbr%3E%20%20%20%20%20%20%20%20formats=[&quot;markdown&quot;],%3Cbr%3E%20%20%20%20%20%20%20%20extract_metadata=True%3Cbr%3E)<br>    content = result.get(&quot;markdown&quot;, &quot;Contenido no disponible&quot;)[:3000] + &quot;...[contenido truncado]&quot;<br>    return f&quot;# Contenido de {url}\n\n{content}&quot;</pre><p>Así definimos al investigador en OpenAI SDK Agents:</p><pre>researcher_agent = Agent(<br>    name=&quot;Researcher&quot;,<br>    instructions=&quot;&quot;&quot;Ejecuta las búsquedas generadas por el Planner usando FireCrawl para recopilar información actualizada y relevante.&quot;&quot;&quot;,<br>    tools=[search_web, extract_from_url],<br>    model=&quot;gpt-4o&quot;,<br>)</pre><p><em>OpenAI tiene ya algunas herramientas pre-construídas que puedes utilizar directamente. </em><a href="https://platform.openai.com/docs/guides/tools?api-mode=responses"><em>Aquí pueds ver el detalle en la documentación oficial</em></a><em>.</em></p><h4>3. Synthesis Agent (Agente de Síntesis)</h4><p>Por último, este agente toma todos los resultados recopilados por el investigador, los organiza y los resume en una respuesta clara y coherente para el usuario final. Esta tarea es esencial para asegurar que la información sea fácil de entender y útil.</p><p>La configuración básica sería:</p><pre>synthesis_agent = Agent(<br>    name=&quot;Synthesis&quot;,<br>    instructions=&quot;&quot;&quot;Sintetiza toda la información recopilada por el Researcher en una respuesta estructurada, completa y fácil de entender.&quot;&quot;&quot;,<br>    tools=[],<br>    model=&quot;o3-mini&quot;,<br>)</pre><h4>Flujo completo del DeepResearch Agent</h4><p>El flujo de interacción entre estos agentes es el siguiente:</p><ol><li>El usuario introduce una pregunta.</li><li><strong>Planner</strong> genera consultas específicas y planifica la búsqueda.</li><li><strong>Researcher</strong> realiza búsquedas web mediante FireCrawl y recopila resultados estructurados.</li><li><strong>Synthesis</strong> sintetiza la información obtenida en un resumen útil y claro.</li></ol><p>Este flujo se ejecuta fácilmente con el Runner del SDK de OpenAI:</p><pre>async def research(question: str) -&gt; str:<br>    planning_result = await Runner.run(planner_agent, input=question)<br>    queries = planning_result.new_items[0].content<br><br>    research_results = await Runner.run(researcher_agent, input=queries)<br>    detailed_info = research_results.new_items[0].content<br><br>    final_result = await Runner.run(synthesis_agent, input=detailed_info)<br>    return final_result.new_items[0].content</pre><p>Con esta estructura, obtenemos un sistema DeepResearch, capaz de ofrecer resultados más precisos que un simple prompt a un LLM con la opción de búsqueda en Internet, manteniendo al mismo tiempo flexibilidad y control tecnológico al integrar herramientas externas como FireCrawl.</p><p>Puedes ver el código completo en <a href="https://github.com/albertgilopez/deep-research-agent"><strong>GitHub</strong></a>.</p><h3>Conclusión: Hacia un ecosistema Agentic Mesh</h3><p>Estos sistemas son solo el inicio, ya existen sistemas como <a href="https://manus.im/">Manus</a>, la nueva IA China generalista que no solo buscan información sino que ejecuta acciones específicas de manera autónoma. Esto es solo el inicio de una evolución más amplia hacia un concepto que promete transformar radicalmente la manera en que operan los agentes de IA: la <strong>Agentic Mesh</strong>. Este paradigma plantea un ecosistema donde múltiples agentes autónomos, especializados en tareas concretas, colaboran entre sí de manera dinámica y flexible, sin quedar restringidos a tecnologías o plataformas específicas. Cada agente podrá descubrir, interactuar y confiar en otros agentes, generando sinergias capaces de abordar tareas complejas con una eficiencia muy superior a la actual, todo a medida que los LLMs seguirán siendo más precisos, más rápidos y se seguirán reduciendo los costes de implementación de estas tecnologías.</p><h3>What’s Next: Próximos Pasos</h3><p>Si quieres seguir explorando este tema, te recomiendo:</p><ol><li><a href="https://platform.openai.com/docs/guides/agents"><strong>Documentación oficial del SDK de Agentes de OpenAI</strong></a></li><li><a href="https://www.anthropic.com/engineering/building-effective-agents"><strong>Building Effective AI Agents — Anthropic</strong></a></li><li><a href="https://medium.com/@jddam/gu%C3%ADa-completa-langgraph-y-el-futuro-de-los-agentes-de-ia-en-2025-2f34ceaa456f"><strong>GUÍA COMPLETA: LangGraph y el futuro de los Agentes de IA en 2025</strong></a></li></ol><p><strong>Comparte tu experiencia:</strong></p><p>Estoy abierto a colaborar y discutir sobre las posibilidades que ofrece la inteligencia artificial y cómo trabajar juntos para explorar y construir soluciones en diferentes sectores. Si tienes ideas, preguntas o simplemente quieres hablar de ello, escríbeme:</p><ul><li><strong>GitHub:</strong> <a href="https://github.com/albertgilopez">https://github.com/albertgilopez</a></li><li><strong>LinkedIn:</strong> <a href="https://www.linkedin.com/in/albertgilopez/">https://www.linkedin.com/in/albertgilopez/</a></li><li><strong>M.IA, tu asistente financiero inteligente:</strong> <a href="https://himia.app/">https://himia.app/</a></li><li><strong>Inteligencia Artificial Generativa en español:</strong> <a href="https://www.codigollm.es/">https://www.codigollm.es/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9a05e64539ac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[TUTORIAL] Cómo analizar NVIDIA en 1 minuto con LangGraph, Tavily Search y la API de la SEC]]></title>
            <link>https://medium.com/@jddam/tutorial-c%C3%B3mo-analizar-nvidia-en-1-minuto-con-langgraph-7e7cf88faefd?source=rss-3723dc84302b------2</link>
            <guid isPermaLink="false">https://medium.com/p/7e7cf88faefd</guid>
            <category><![CDATA[sec]]></category>
            <category><![CDATA[financial-analysis]]></category>
            <category><![CDATA[langgraph]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[agents]]></category>
            <dc:creator><![CDATA[Albert Gil López]]></dc:creator>
            <pubDate>Mon, 13 Jan 2025 21:42:14 GMT</pubDate>
            <atom:updated>2025-01-13T22:01:15.636Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/881/1*-OsBHKJHy6vTBJTCUVx1bg.png" /><figcaption>AUTOR: Claude 3.5 Sonnet</figcaption></figure><p>Es un buen momento para comprar acciones de <a href="https://finance.yahoo.com/quote/NVDA/?guccounter=1&amp;guce_referrer=aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS8&amp;guce_referrer_sig=AQAAALlhuyMXSq_Ud582I-XABFLuX-KFwp0Tgu87AgmOuc4b3mlHwi2XSitKcZHuMlQqLLEhn_dbTf3svpF-Fju7oR0pFORuWw7U2Ofjvkt4igiPykvtsx8W5SRbhc5rFglB6txc10iZ3dt7ODqfIQ7VwMN_cQqAcwauX3FjEqeEQ5L-">NVIDIA</a>, (o de alguna empresa cuántica), o al menos es parece después de haber analizado su situación financiera en apenas un minuto.</p><p>Evidentemente, este artículo no supone ningún consejo de inversión, sino más bien una demostración del potencial de los agentes autónomos. El flujo que verás a continuación te permite analizar empresas como NVIDIA en apenas un minuto y generar insights financieros accionables de manera automatizada.</p><h3>Background: la evolución de los agentes de IA en 2025</h3><p>Los agentes representan el siguiente paso en la evolución de la IA. En este otro <a href="https://medium.com/@jddam/gu%C3%ADa-completa-langgraph-y-el-futuro-de-los-agentes-de-ia-en-2025-2f34ceaa456f">artículo</a> hablaba del futuro de los agentes de IA este 2025. Mientras que los modelos de lenguaje fundamentales son reactivos y dependen de prompts constantes, los agentes pueden mantener un estado, ejecutar tareas complejas y tomar decisiones de manera autónoma.</p><p>LangGraph se posiciona como una herramienta fundamental en este contexto, permitiendo:</p><ul><li><strong>Mantenimiento de estado coherente</strong></li><li><strong>Ejecución de flujos complejos</strong></li><li><strong>Coordinación entre múltiples agentes</strong></li><li><strong>Gestión de interrupciones y reanudaciones</strong></li></ul><p>En este tutorial vamos a ver un caso de uso específico realizando una investigación empresarial de manera automatizada. En el ejemplo, implementaremos un asistente de investigación empresarial que puede:</p><p><strong>1. Recopilar información inicial sobre la empresa<br>2. Extraer y analizar datos financieros de la SEC<br>3. Generar informes estructurados<br>4. Publicar resultados en formatos accesibles</strong></p><p>La arquitectura que implementamos es una versión reducida que se puede ampliar y mejorar de muchas maneras <em>(pero que es suficiente sirve para explicar el objetivo de este artículo)</em>, y está modelada en LangGraph. Utiliza nodos para cada etapa del proceso y mantiene un estado compartido:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/457/1*xHP4e--qTN5U60KlsZwrVw.png" /><figcaption>AUTOR: Albert Gil López (Mermaid)</figcaption></figure><h3>Hands On: Implementación paso a paso</h3><p>Cada nodo en nuestro grafo tiene una responsabilidad específica:</p><p><strong>1. Initial Grounding:<br></strong> — Establece el contexto inicial<br> — Recopila información básica de la empresa<br> — Prepara el estado para el análisis</p><p><strong>2. SEC Data Extraction:<br></strong> — Conecta con la API de la SEC<br> — Extrae datos financieros clave<br> — Estructura la información para análisis</p><p><strong>3. Generate Report:<br></strong> — Analiza los datos recopilados<br> — Genera insights accionables<br> — Estructura el informe final</p><p><strong>4. Publish:<br></strong> — Formatea los resultados<br> — Genera documentos accesibles<br> — Distribuye la información</p><p>Esta es una versión simplificada del código:</p><pre>from typing import Dict, List, Optional<br>from pydantic import BaseModel<br>from langchain_core.messages import SystemMessage<br>from langgraph.graph import StateGraph<br><br>class ResearchState(BaseModel):<br>    &quot;&quot;&quot;Estado para el flujo de investigación.&quot;&quot;&quot;<br>    company: str<br>    initial_research: Optional[Dict] = None<br>    sec_data: Optional[Dict] = None<br>    report_content: Optional[str] = None<br>    report_path: Optional[str] = None<br>    messages: List[str] = []<br><br>def initial_grounding(state: ResearchState):<br>    &quot;&quot;&quot;Nodo de recopilación inicial.&quot;&quot;&quot;<br>    print(f&quot;Iniciando investigación para {state.company}&quot;)<br>    # Implementación de la recopilación inicial<br>    state.initial_research = {<br>        &quot;company_name&quot;: state.company,<br>        &quot;status&quot;: &quot;grounded&quot;,<br>        &quot;sector&quot;: &quot;Technology&quot;,<br>        &quot;market&quot;: &quot;NASDAQ&quot;<br>    }<br>    return state<br><br>def extract_sec_data(state: ResearchState):<br>    &quot;&quot;&quot;Nodo de extracción de datos de la SEC.&quot;&quot;&quot;<br>    print(&quot;Extrayendo datos de la SEC...&quot;)<br>    # Integración con la API de la SEC<br>    state.sec_data = {<br>        &quot;financials&quot;: {<br>            &quot;revenue&quot;: 26974000000,<br>            &quot;profit&quot;: 9243000000,<br>            &quot;profit_margin&quot;: 0.34,<br>            &quot;growth_rate&quot;: 0.34<br>        }<br>    }<br>    return state<br><br>def generate_report(state: ResearchState):<br>    &quot;&quot;&quot;Nodo de generación de informe.&quot;&quot;&quot;<br>    print(&quot;Generando informe...&quot;)<br>    financials = state.sec_data[&quot;financials&quot;]<br>    <br>    state.report_content = f&quot;&quot;&quot;<br>    Análisis Financiero de {state.company}<br>    ================================<br>    <br>    Resultados Principales:<br>    - Ingresos: ${financials[&#39;revenue&#39;]:,}<br>    - Beneficio: ${financials[&#39;profit&#39;]:,}<br>    - Margen de beneficio: {financials[&#39;profit_margin&#39;]*100:.1f}%<br>    - Tasa de crecimiento: {financials[&#39;growth_rate&#39;]*100:.1f}%<br>    <br>    Análisis:<br>    La empresa muestra un fuerte rendimiento financiero con márgenes<br>    de beneficio saludables y un crecimiento significativo.<br>    &quot;&quot;&quot;<br>    return state<br><br>def publish_report(state: ResearchState):<br>    &quot;&quot;&quot;Nodo de publicación.&quot;&quot;&quot;<br>    print(&quot;Publicando informe...&quot;)<br>    file_path = f&quot;reports/{state.company.lower()}_report.pdf&quot;<br>    with open(file_path, &quot;w&quot;) as f:<br>        f.write(state.report_content)<br>    state.report_path = file_path<br>    return state<br><br># Configuración del grafo<br>workflow = StateGraph(ResearchState)<br><br># Agregar nodos<br>workflow.add_node(&quot;initial_grounding&quot;, initial_grounding)<br>workflow.add_node(&quot;extract_sec_data&quot;, extract_sec_data)<br>workflow.add_node(&quot;generate_report&quot;, generate_report)<br>workflow.add_node(&quot;publish_report&quot;, publish_report)<br><br># Conectar nodos<br>workflow.add_edge(&quot;initial_grounding&quot;, &quot;extract_sec_data&quot;)<br>workflow.add_edge(&quot;extract_sec_data&quot;, &quot;generate_report&quot;)<br>workflow.add_edge(&quot;generate_report&quot;, &quot;publish_report&quot;)<br><br># Configurar puntos de entrada y salida<br>workflow.set_entry_point(&quot;initial_grounding&quot;)<br>workflow.set_finish_point(&quot;publish_report&quot;)<br><br># Ejemplo de uso<br>state = ResearchState(company=&quot;NVIDIA&quot;)<br>final_state = workflow.run(state)<br>print(f&quot;Informe generado en: {final_state.report_path}&quot;)</pre><p>En el siguiente <a href="https://github.com/albertgilopez/agents"><strong>enlace</strong></a><strong> </strong>puedes descargar el código, y <a href="https://company-research-525373923741.europe-west1.run.app/"><strong>aquí</strong></a><strong> </strong>puedes probar el proyecto desplegado en Google Cloud Platform. <em>(PD: El código está basado en el </em><a href="https://blog.tavily.com/companyresearcher/"><em>artículo</em></a><em> de Danielle Yahalom en Tavily Search Blog)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*lcEtM0dktlq0YtqrbEMOEA.png" /><figcaption>AUTOR: Albert Gil López (Deploy Company Research en GCP)</figcaption></figure><h3>Conclusión</h3><p>Al igual que LangGraph, existen otros frameworks (Crewai, Autogen, …) pensados para implementar y orquestrar agentes autónomos, te invito a descubrirlos. En este otro <a href="https://medium.com/@jddam/think-digital-summit-2024-ai-agentic-y-dise%C3%B1o-de-sistemas-multi-agente-dcbcd00cdf03">artículo</a> comento dos cursos que quizás te pueden interesar. El caso de uso de investigación empresarial ilustra cómo podemos automatizar tareas complejas manteniendo un alto nivel de precisión y eficiencia.</p><h3>What’s Next: Próximos Pasos</h3><p>Si quieres seguir explorando este tema, te recomiendo:</p><p><strong>1. [Documentación oficial de LangGraph](</strong><a href="https://langchain-ai.github.io/langgraph/"><strong>https://langchain-ai.github.io/langgraph/</strong></a><strong>)<br>2. [API de la SEC](</strong><a href="https://sec-api.io/docs/financial-statements"><strong>https://sec-api.io/docs/financial-statements</strong></a><strong>)<br>3. [GUÍA COMPLETA] LangGraph y el futuro de los Agentes de IA en 2025 (</strong><a href="https://medium.com/@jddam/gu%C3%ADa-completa-langgraph-y-el-futuro-de-los-agentes-de-ia-en-2025-2f34ceaa456f"><strong>https://medium.com/@jddam/gu%C3%ADa-completa-langgraph-y-el-futuro-de-los-agentes-de-ia-en-2025-2f34ceaa456f</strong></a><strong>)</strong></p><p><strong>Comparte tu experiencia:</strong></p><p>Estoy abierto a colaborar y discutir sobre las posibilidades que ofrece la inteligencia artificial y cómo trabajar juntos para explorar y construir soluciones en diferentes sectores. Si tienes ideas, preguntas o simplemente quieres hablar de ello, escríbeme:</p><ul><li>GitHub: <a href="https://github.com/albertgilopez">https://github.com/albertgilopez</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/albertgilopez/">https://www.linkedin.com/in/albertgilopez/</a></li><li>M.IA, tu asistente financiero inteligente: <a href="https://himia.app/">https://himia.app/</a></li><li>Inteligencia Artificial Generativa en español: <a href="https://www.codigollm.es/">https://www.codigollm.es/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7e7cf88faefd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[GUÍA COMPLETA] LangGraph y el futuro de los Agentes de IA en 2025]]></title>
            <link>https://medium.com/@jddam/gu%C3%ADa-completa-langgraph-y-el-futuro-de-los-agentes-de-ia-en-2025-2f34ceaa456f?source=rss-3723dc84302b------2</link>
            <guid isPermaLink="false">https://medium.com/p/2f34ceaa456f</guid>
            <category><![CDATA[agentic-mesh]]></category>
            <category><![CDATA[agents]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[langchain]]></category>
            <category><![CDATA[langgraph]]></category>
            <dc:creator><![CDATA[Albert Gil López]]></dc:creator>
            <pubDate>Thu, 19 Dec 2024 05:18:13 GMT</pubDate>
            <atom:updated>2025-01-13T21:24:58.205Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/877/1*6PyTHK0bNr0jwdI_Q78KeA.png" /><figcaption>AUTOR: Claude 3.5 Sonnet</figcaption></figure><h3>Introducción</h3><p>Crear agentes de inteligencia artificial capaces de mantener un estado coherente y ejecutar tareas complejas de manera estructurada es uno de los retos más emocionantes del desarrollo de aplicaciones de IA.</p><p>Para entender la magnitud de este cambio, tienes que imaginar la diferencia entre tener un asistente personal que necesita instrucciones constantes para cada tarea y contar con un equipo completo de profesionales especializados que pueden colaborar entre sí para resolver problemas complejos. Esta analogía nos ayuda a visualizar el salto cualitativo que estamos presenciando: el paso de chatbots reactivos a verdaderos agentes autónomos interconectados.</p><p>Para abordar este futuro, estan surgiendo herramientas como LangGraph que permiten diseñar agentes con lógica avanzada y “fáciles” de mantener.</p><p>En este artículo implementaremos a modo de ejemplo un agente de escritura utilizando LangGraph, y haremos un giño al futuro de la IA Generativa este próximo 2025.</p><h3>Background: la evolución hacia los Agentes de IA</h3><p>El desarrollo tecnológico en IA pasa por un momento de transición crítico. Los modelos de lenguaje como GPT-4, Claude 3.5 Sonnet o Gemini, han demostrado capacidades impresionantes para entender y generar texto, pero operan principalmente como sistemas de pregunta-respuesta, requiriendo una supervisión constante y carecen de la capacidad para mantener un estado coherente a lo largo de tareas complejas. Es como tener una conversación con alguien que, aunque brillante, olvida todo el contexto previo cada vez que parpadea.</p><p>Pero primero, vamos a entender de dónde venimos:</p><h4>(2017–2021)</h4><p>Todo empieza (aunque viene de mucho más atrás) con la arquitectura <em>Transformer</em>, introducida en 2017 con el paper <a href="https://arxiv.org/abs/1706.03762"><em>“Attention is All You Need”</em></a>. Esta arquitectura revolucionó el procesamiento del lenguaje natural por dos razones principales. Primero, permitió procesar texto de manera paralela, superando las limitaciones de las arquitecturas secuenciales anteriores. Segundo, introdujo el mecanismo de atención, que permitía a los modelos “concentrarse” en las partes más relevantes del texto.</p><p>La arquitectura <em>Transformer </em>sentó las bases para el desarrollo de los grandes modelos de lenguaje (LLMs). Estos modelos, entrenados con cantidades masivas de texto,<a href="https://research.google/blog/pathways-language-model-palm-scaling-to-540-billion-parameters-for-breakthrough-performance/"> comenzaron a mostrar capacidades sorprendentes para entender y generar lenguaje natural, además de muchas otras funciones</a>. Sin embargo, todavía operaban principalmente como sistemas de predicción de texto, sin capacidad real para mantener un estado o ejecutar planes complejos.</p><h4>(2022–2023)</h4><p>El lanzamiento de ChatGPT en noviembre de 2022 marcó el inicio de una nueva era en la interacción humano-máquina. Por primera vez, teníamos un sistema capaz de mantener conversaciones coherentes y realizar tareas complejas a través del diálogo. Las características clave de esta era fueron:</p><p><strong>1. Interacción basada en prompts</strong>: Los usuarios necesitaban guiar constantemente al sistema a través de instrucciones específicas.</p><p><strong>2. Ausencia de memoria a largo plazo</strong>: Cada conversación era independiente, sin capacidad para recordar interacciones anteriores.</p><p><strong>3. Limitaciones en la ejecución</strong>: Aunque podían generar planes, no tenían capacidad real para ejecutarlos de manera autónoma.</p><p>Para ilustrar estas limitaciones, imaginemos una persona que puede escribir recetas de cocina, pero no puede realmente cocinar ni coordinar con otros en la cocina. Puede dar instrucciones brillantes, pero carece de la autonomía para llevarlas a cabo.</p><h4>(2024)</h4><p>Este 2024 ha marcado un punto de inflexión crucial con la introducción de los primeros agentes autónomos verdaderos. Empresas como Microsoft lideraron este avance con el lanzamiento de agentes especializados en ventas y soporte al cliente. Estos agentes representaron un salto cualitativo por varias razones:</p><p><strong>1. Mantenimiento de estado</strong>: Podían recordar y actualizar información a lo largo de múltiples interacciones.</p><p><strong>2. Capacidad de planificación</strong>: No solo generaban planes, sino que podían ejecutarlos y ajustarlos según fuera necesario.</p><p><strong>3. Especialización</strong>: Cada agente se centraba en un dominio específico, permitiendo un rendimiento superior en tareas concretas.</p><h4>(2025)</h4><p>Ahora, en 2025, presenciaremos la siguiente evolución: el surgimiento del concepto <a href="https://towardsdatascience.com/agentic-mesh-the-future-of-generative-ai-enabled-autonomous-agent-ecosystems-d6a11381c979"><em>Agentic Mesh</em></a>. Este concepto representa un salto cualitativo en la manera en que los agentes de IA operan y colaboran:</p><p><strong>1. Interconexión</strong>: Los agentes pueden descubrirse y colaborar entre sí de manera autónoma, formando equipos dinámicos según las necesidades.</p><p><strong>2. Especialización profunda</strong>: Cada agente puede centrarse en una tarea específica, sabiendo que puede colaborar con otros agentes para tareas fuera de su especialidad.</p><p><strong>3. Gestión de estado distribuida</strong>: La información y el contexto se comparten de manera efectiva entre múltiples agentes.</p><p><strong>4. Sistemas de confianza</strong>: Mecanismos integrados para verificar la fiabilidad y capacidades de los agentes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5740uhvjF4gy9ZiWNSL82A.jpeg" /><figcaption><a href="https://www.linkedin.com/posts/olivermolander_artificialintelligence-agents-verticalai-activity-7274330114409025536-F9OO?utm_source=share&amp;utm_medium=member_desktop">https://www.linkedin.com/posts/olivermolander_artificialintelligence-agents-verticalai-activity-7274330114409025536-F9OO?utm_source=share&amp;utm_medium=member_desktop</a></figcaption></figure><p>Por lo tanto, ahora necesitamos crear agentes de IA que puedan:</p><ul><li><strong>Mantener un estado coherente a lo largo del tiempo</strong></li><li><strong>Tomar decisiones autónomas basadas en objetivos claros</strong></li><li><strong>Colaborar con otros agentes de manera efectiva</strong></li><li><strong>Ejecutar tareas complejas sin supervisión constante</strong></li></ul><p>Es aquí donde LangGraph aparece como ejemplo de herramienta imprescindible.</p><h4>LangGraph: ¿Por qué LangGraph?</h4><p>Existen herramientas de orquestación de modelos de lenguaje, pero presentan limitaciones significativas:</p><ul><li>No mantienen estado entre interacciones.</li><li>Carecen de flexibilidad para implementar bucles o condiciones complejas.</li><li>Dificultan el manejo de interrupciones y reanudaciones.</li></ul><p><a href="https://www.langchain.com/langgraph"><strong>LangGraph</strong></a><strong> </strong>resuelve estos problemas al introducir un enfoque basado en grafos de estado, permitiendo flujos de trabajo sofisticados y personalizados. Tiene los siguientes componentes principales:</p><ol><li><strong>StateGraph</strong>: Define la estructura y el flujo del agente.</li><li><strong>AgentState</strong>: Mantiene el estado actual del agente.</li><li><strong>Nodos</strong>: Representan pasos específicos en el flujo.</li><li><strong>Edges</strong>: Conectan nodos, estableciendo las transiciones lógicas.</li></ol><h3>Hands On: Writer Agent with LangGraph</h3><p>Siguendo con el ejemplo del chef, necesitamos la manera de recordar qué platos están en preparación, qué ingredientes se han utilizado, y coordinar con su equipo. De manera similar, nuestros agentes necesitan mantener un registro de sus tareas y progreso.</p><p>Veamos cómo implementamos esto en la práctica con un ejemplo de un agente con la capacidad para planificar tareas:</p><pre>from typing import TypedDict, Annotated, List, Dict<br>from langchain_core.messages import SystemMessage, HumanMessage<br>from langgraph.graph import StateGraph<br>from langchain_openai import ChatOpenAI<br>import operator<br><br>class PlannerState(TypedDict):<br>    # Objetivo y contexto<br>    main_objective: str        # Objetivo principal<br>    constraints: List[str]     # Restricciones y limitaciones<br>    available_resources: Dict  # Recursos disponibles<br>    <br>    # Estado de planificación<br>    current_plan: Dict[str, any]        # Plan actual con sus componentes<br>    subtasks: List[Dict]                # Lista de subtareas identificadas<br>    dependencies: Dict[str, List[str]]  # Dependencias entre tareas<br>    <br>    # Control de progreso<br>    completed_tasks: List[str]     # Tareas completadas<br>    blocked_tasks: List[str]       # Tareas bloqueadas<br>    task_status: Dict[str, str]    # Estado de cada tarea<br>    <br>    # Metadatos<br>    lnode: str                            # Último nodo ejecutado<br>    steps: Annotated[int, operator.add]   # Contador de pasos</pre><p>Este modelo de estado es como el cerebro de nuestro agente. Cada campo tiene un propósito específico.</p><p>La arquitectura de flujo en LangGraph se asemeja a un mapa de proceso bien organizado. Imagínatelo como una línea de producción donde cada estación tiene una tarea específica y sabe exactamente qué hacer con el producto que recibe.</p><p>Se definen unos prompts que actúan como “personalidades” especializadas. El <strong>PLAN_PROMPT </strong>actúa como un planificador que ayuda a abordar la tarea, mientras que el <strong>EXECUTION_PROMPT </strong>toma el papel de una ejecutor que lleva a cabo la tarea.</p><pre># Definimos los prompts que guiarán cada etapa del proceso<br>PLAN_PROMPT = &quot;&quot;&quot;Como experto en planificación, tu tarea es:<br>1. Analizar el objetivo principal<br>2. Desglosar en pasos concretos<br>3. Identificar posibles obstáculos<br>4. Establecer puntos de verificación<br>Proporciona un plan estructurado y claro.&quot;&quot;&quot;<br><br>EXECUTION_PROMPT = &quot;&quot;&quot;Basándote en el plan proporcionado:<br>1. Ejecuta cada paso con precisión<br>2. Documenta el progreso<br>3. Identifica cualquier ajuste necesario<br>Mantén el enfoque en el objetivo principal.&quot;&quot;&quot;</pre><p>Luego, se implementa cada fase del proceso de planificación como nodos en nuestro grafo. Cada nodo representa una etapa distinta del proceso:</p><pre># Implementamos los nodos del flujo<br>def plan_node(state: AgentState):<br>    &quot;&quot;&quot;<br>    Este nodo se encarga de la planificación inicial.<br>    Recibe el estado actual y genera un plan estructurado.<br>    &quot;&quot;&quot;<br>    messages = [<br>        SystemMessage(content=PLAN_PROMPT), <br>        HumanMessage(content=state[&#39;task&#39;])<br>    ]<br>    response = model.invoke(messages)<br>    <br>    # Procesamos y validamos el plan<br>    plan = validate_plan(response.content)<br>    <br>    return {<br>        &quot;plan&quot;: plan,<br>        &quot;lnode&quot;: &quot;plan&quot;,<br>        &quot;steps&quot;: 1<br>    }<br><br>def generation_node(state: AgentState):<br>    &quot;&quot;&quot;<br>    Este nodo ejecuta el plan y genera resultados.<br>    Utiliza el plan creado anteriormente como guía.<br>    &quot;&quot;&quot;<br>    context = f&quot;Plan actual: {state[&#39;plan&#39;]}\nTarea: {state[&#39;task&#39;]}&quot;<br>    messages = [<br>        SystemMessage(content=EXECUTION_PROMPT),<br>        HumanMessage(content=context)<br>    ]<br>    response = model.invoke(messages)<br>    <br>    return {<br>        &quot;draft&quot;: response.content,<br>        &quot;lnode&quot;: &quot;generate&quot;,<br>        &quot;steps&quot;: 1<br>    }<br><br>[...]</pre><p>La magia de LangGraph se manifiesta en cómo conectamos estos nodos para crear un flujo de trabajo coherente:</p><pre># Configuramos el grafo de ejecución<br>builder = StateGraph(AgentState)<br>builder.add_node(&quot;planner&quot;, plan_node)<br>builder.add_node(&quot;generate&quot;, generation_node)<br>builder.add_node(&quot;reflect&quot;, reflection_node)<br>builder.add_node(&quot;research_plan&quot;, research_plan_node)<br><br># Definimos la lógica de flujo<br>builder.set_entry_point(&quot;planner&quot;)<br>builder.add_conditional_edges(<br>    &quot;generate&quot;,<br>    should_continue,<br>    {END: END, &quot;reflect&quot;: &quot;reflect&quot;}<br>)</pre><p>Esta arquitectura implementa un flujo de trabajo que:</p><ol><li>Comienza con la planificación estratégica</li><li>Avanza hacia la ejecución del plan</li><li>Incluye puntos de reflexión y revisión</li><li>Permite la investigación adicional cuando es necesaria</li></ol><p>Pero necesitamos asegurarnos que nuestro agente funcione de manera efectiva, implementamos un sistema de control y retroalimentación:</p><pre>def should_continue(state: AgentState) -&gt; str:<br>    &quot;&quot;&quot;<br>    Decide si el proceso debe continuar o terminar.<br>    Evalúa múltiples factores para tomar la decisión.<br>    &quot;&quot;&quot;<br>    # Verificamos si hemos alcanzado el límite de revisiones<br>    if state[&quot;revision_number&quot;] &gt; state[&quot;max_revisions&quot;]:<br>        return END<br>    <br>    # Evaluamos la calidad del resultado actual<br>    quality_score = evaluate_quality(state[&quot;draft&quot;])<br>    if quality_score &gt;= 0.95:<br>        return END<br>    <br>    # Si necesitamos más información<br>    if quality_score &lt; 0.7:<br>        return &quot;research_plan&quot;<br>    <br>    # En otros casos, continuamos con la reflexión<br>    return &quot;reflect&quot;<br><br># Implementamos el sistema de memoria persistente<br>memory = SqliteSaver(<br>    conn=sqlite3.connect(&quot;:memory:&quot;, check_same_thread=False),<br>    table_name=&quot;agent_states&quot;<br>)<br><br># Configuramos el grafo con control de interrupciones<br>graph = builder.compile(<br>    checkpointer=memory,<br>    interrupt_after=[&#39;planner&#39;, &#39;generate&#39;, &#39;reflect&#39;]<br>)</pre><p>El sistema evalúa constantemente la calidad del trabajo, decide cuándo es necesario más investigación, mantiene un registro del progreso y permite interrumpir y reanudar el proceso de manera segura</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/1*9JsWdSrpycNOnwT3nYW2CA.png" /></figure><h3>Conclusiones: más allá del pre-entrenamiento</h3><p>Como señaló <a href="https://es.wikipedia.org/wiki/Ilya_Sutskever"><strong>Ilya Sutskever</strong></a> en su reciente charla en <a href="https://neurips.cc/">NeurIPS 2024</a>, nos encontramos en un punto de inflexión crítico en la evolución de la IA. El pre-entrenamiento, que ha sido el motor principal del progreso en los últimos años, llegará inevitablemente a su fin por una razón fundamental: <em>“tenemos solo un Internet”</em>, es decir, hay una limitación con los datos. Esta observación profunda nos lleva a repensar el futuro de la IA y el papel que jugarán los agentes autónomos.</p><h4>La evolución hacia un ecosistema Agentic</h4><p>¿Un marketplace de agentes? La implementación actual de LangGraph ya anticipa este futuro post-pre-entrenamiento. Veamos cómo se estructura este ecosistema:</p><pre># Sistema de registro y descubrimiento de agentes<br>class AgentRegistry:<br>    def __init__(self, storage_connection):<br>        self.storage = storage_connection<br>        self.capabilities_index = {}<br>        self.trust_scores = {}<br>    <br>    def register_agent(self, agent_id: str, capabilities: List[str], <br>                      trust_score: float = 0.0):<br>        &quot;&quot;&quot;Registra un nuevo agente en el ecosistema.&quot;&quot;&quot;<br>        self.capabilities_index[agent_id] = capabilities<br>        self.trust_scores[agent_id] = trust_score<br>        <br>    def find_agents_by_capability(self, required_capability: str) -&gt; List[str]:<br>        &quot;&quot;&quot;Encuentra agentes que pueden realizar una tarea específica.&quot;&quot;&quot;<br>        return [agent_id for agent_id, caps in self.capabilities_index.items()<br>                if required_capability in caps]<br><br># Ejemplo de uso en el sistema de memoria<br>memory = SqliteSaver(conn=sqlite3.connect(&quot;:memory:&quot;, check_same_thread=False))<br>registry = AgentRegistry(memory.conn)<br><br>graph = builder.compile(<br>    checkpointer=memory,<br>    registry=registry,<br>    interrupt_after=[&#39;planner&#39;, &#39;generate&#39;, &#39;reflect&#39;]<br>)</pre><p>Este sistema permitiría que los agentes:</p><ul><li>Se registren con sus capacidades específicas</li><li>Sean descubiertos por otros agentes según las necesidades</li><li>Mantengan un historial de confianza y rendimiento</li></ul><p>Como señala Sutskever, los sistemas futuros <em>“razonarán de verdad”</em>, y esto los hará más impredecibles pero también más capaces. LangGraph ya implementa estructuras para este tipo de razonamiento:</p><pre>def reasoning_node(state: AgentState):<br>    &quot;&quot;&quot;<br>    Implementa capacidades de razonamiento basadas en el contexto y la experiencia.<br>    &quot;&quot;&quot;<br>    context = compile_context(state)<br>    reasoning_prompt = create_reasoning_prompt(context)<br>    <br>    # Utiliza un modelo específico para razonamiento<br>    reasoning_response = reasoning_model.invoke(<br>        messages=[<br>            SystemMessage(content=reasoning_prompt),<br>            HumanMessage(content=state[&#39;current_situation&#39;])<br>        ]<br>    )<br>    <br>    # Valida y refina el razonamiento<br>    validated_reasoning = validate_reasoning(reasoning_response.content)<br>    <br>    return {<br>        &quot;reasoning_path&quot;: validated_reasoning,<br>        &quot;confidence_score&quot;: evaluate_confidence(validated_reasoning),<br>        &quot;next_steps&quot;: determine_next_steps(validated_reasoning),<br>        &quot;lnode&quot;: &quot;reason&quot;<br>    }</pre><p>Ante la limitación de datos de Internet, el ecosistema necesita evolucionar hacia la generación de datos sintéticos y el aprendizaje continuo. Como señala Sutskever, el futuro no solo traerá sistemas más capaces, sino <em>“cualitativamente diferentes”</em> de lo que tenemos hoy.</p><p>La clave está en crear sistemas que no solo puedan procesar información, sino que puedan razonar, aprender continuamente y colaborar de manera efectiva con otros agentes y con humanos.</p><h3>What’s Next: Próximos Pasos</h3><p>Las predicciones de Ilya Sutskever en NeurIPS 2024 se alinean con una visión más amplia del mercado. Por ejemplo, <a href="https://www.youtube.com/watch?v=ASABxNenD_U">Y Combinator proyecta que los agentes verticales de IA podrían ser hasta 10 veces más grandes que el mercado SaaS actual</a>.</p><p>La transformación que estamos presenciando va más allá de una simple evolución tecnológica. Los agentes verticales de IA representan una oportunidad de mercado que podría eclipsar la revolución del SaaS de los años 2000:</p><ul><li><em>Los agentes de IA no solo reemplazan costos de software, también optimizan significativamente los costos laborales. Hay un potencial para crear compañías valoradas en más de $300 mil millones solo en la categoría de agentes verticales</em></li><li><em>A nivel de eficiencia operativa, las empresas gastan considerablemente más en empleados que en software. Los agentes permiten operaciones más eficientes con menos recursos humanos</em></li></ul><p>Como conclusión final, la convergencia entre el fin del pre-entrenamiento tradicional y el surgimiento de agentes verticales marca el inicio de algo nuevo en la tecnología empresarial. Si comprendes y adoptas esta transformación estarás mejor posicionado para aprovechar una oportunidad de mercado que podría superar ampliamente la revolución del SaaS.</p><ul><li><em>La Visión de Ilya Sutskever sobre el Futuro de la IA<br>En su reveladora charla en NeurIPS 2024, Ilya Sutskever presentó conceptos fundamentales sobre el futuro de la IA:</em><strong> [Charla completa de Ilya Sutskever en NeurIPS 2024](</strong><a href="https://www.youtube.com/watch?v=1yvBqasHLZs"><strong>https://www.youtube.com/watch?v=1yvBqasHLZs</strong></a><strong>)</strong></li><li><strong>[Building AI Agents with LangGraph](</strong><a href="https://www.deeplearning.ai/short-courses/ai-agents-in-langgraph/"><strong>https://www.deeplearning.ai/short-courses/ai-agents-in-langgraph/</strong></a><strong>)</strong></li><li><strong>[Documentación oficial de LangGraph](</strong><a href="https://www.langchain.com/langgraph"><strong>https://www.langchain.com/langgraph</strong></a><strong>)</strong></li></ul><p>Entre mis artículos que pueden complementar este tema:</p><ul><li><a href="https://medium.com/@jddam/think-digital-summit-2024-ai-agentic-y-dise%C3%B1o-de-sistemas-multi-agente-dcbcd00cdf03"><strong>“Think Digital Summit 2024: AI Agentic y diseño de sistemas multi-agente”</strong></a></li><li><a href="https://medium.com/@jddam/comparativa-naive-rag-vs-react-agent-utilizando-llamaindex-24fb11577574"><strong>“Comparativa Naive RAG vs ReAct Agent utilizando LlamaIndex”</strong></a></li><li><a href="https://medium.com/@jddam/from-rag-to-deploy-building-and-deploying-a-retrieval-augmented-generation-rag-app-a9657ae57cca"><strong>“From RAG to Deploy: Building and Deploying a Retrieval Augmented Generation (RAG) App”</strong></a></li></ul><p><strong>Comparte tu experiencia:</strong></p><p>Estoy abierto a colaborar y discutir sobre las posibilidades que ofrece la inteligencia artificial y cómo trabajar juntos para explorar y construir soluciones en diferentes sectores. Si tienes ideas, preguntas o simplemente quieres hablar de ello, escríbeme:</p><ul><li>GitHub: <a href="https://github.com/albertgilopez">https://github.com/albertgilopez</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/albertgilopez/">https://www.linkedin.com/in/albertgilopez/</a></li><li>M.IA, tu asistente financiero inteligente: <a href="https://himia.app/">https://himia.app/</a></li><li>Inteligencia Artificial Generativa en español: <a href="https://www.codigollm.es/">https://www.codigollm.es/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2f34ceaa456f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Digitalizando tus Finanzas. De imágenes (o PDFs) a datos estructurados: OCR vs LLMs]]></title>
            <link>https://medium.com/@jddam/digitalizando-tus-finanzas-de-im%C3%A1genes-o-pdfs-a-datos-estructurados-ocr-vs-llms-26515a3f2fe2?source=rss-3723dc84302b------2</link>
            <guid isPermaLink="false">https://medium.com/p/26515a3f2fe2</guid>
            <category><![CDATA[ocr]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[finance]]></category>
            <category><![CDATA[unstructured-data]]></category>
            <category><![CDATA[invoice]]></category>
            <dc:creator><![CDATA[Albert Gil López]]></dc:creator>
            <pubDate>Sun, 18 Aug 2024 19:07:33 GMT</pubDate>
            <atom:updated>2024-08-19T06:24:47.932Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0XZl27odU-fUCCFIQBMbTw.jpeg" /><figcaption>AUTOR: DALL-E 3</figcaption></figure><p>Este es el tercer artículo de la saga. En los dos artículos anteriores, hemos analizado la capacidad de métodos tradicionales, como el OCR, y los LLMs (Large Language Models) para la extracción de información de documentos financieros. En este artículo (un poco más extenso que el resto) vamos a compararlos y ponerlos a competir. La pregunta clave es: ¿cómo podemos extraer la información relevante de estos documentos de la manera más eficiente y precisa? ¿Debemos seguir confiando en tecnologías tradicionales como el OCR, o es momento de adoptar una tecnología más avanzada?</p><h3>Introducción</h3><p>A todos nos ha pasado alguna vez. Tienes montones de facturas, informes financieros, y documentos que necesitas digitalizar y procesar. Hace unos años, el OCR era la herramienta de referencia, y no se podía pedir más. Sin embargo, con la evolución de la inteligencia artificial generativa, las cosas han cambiado. Ahora, los LLMs ofrecen una alternativa mucho más robusta, capaz de entender el contexto, interpretar imágenes y proporcionar datos estructurados.</p><p>Entonces, ¿qué enfoque deberías elegir para digitalizar tus finanzas? Vamos a descubrirlo (aunque yo creo que ya lo has deducido).</p><h3>Background: OCR vs. LLMs</h3><h3>OCR (Reconocimiento Óptico de Caracteres)</h3><p>El OCR es una tecnología madura y bien establecida. Convierte imágenes de texto en texto “digital” editable, lo que facilita la digitalización de documentos físicos como facturas, contratos, y más. La ventaja principal del OCR es su rapidez y facilidad de implementación, especialmente cuando se trata de textos bien formateados y claros.</p><p><strong>Ventajas de OCR:</strong></p><ul><li><strong>Fiabilidad:</strong> Una solución rentable y fácil de implementar.</li><li><strong>Velocidad:</strong> Procesa documentos rápidamente, ideal para grandes volúmenes.</li><li><strong>Costo:</strong> Generalmente más económico, especialmente para tareas básicas.</li></ul><p><strong>Desventajas de OCR:</strong></p><ul><li><strong>Contexto:</strong> No puede interpretar la semántica del texto.</li><li><strong>Precisión:</strong> Depende en gran medida de la calidad de la imagen.</li><li><strong>Estructuración de Datos:</strong> Requiere pasos adicionales para estructurar la información extraída.</li></ul><h3>LLMs (Large Language Models)</h3><p>Los LLMs, como los modelos Gemini o GPT-4o, representan la vanguardia en procesamiento de lenguaje natural e imágenes. No solo extraen texto, sino que también comprenden el contexto y la semántica de la información, proporcionando datos mucho más ricos y útiles.</p><p><strong>Ventajas de LLMs:</strong></p><ul><li><strong>Contexto:</strong> Entienden y procesan la semántica del texto, lo que mejora la precisión de la extracción de datos.</li><li><strong>Flexibilidad:</strong> Adaptables a diferentes tipos de documentos y formatos.</li><li><strong>Multimodalidad:</strong> Capaces de procesar tanto texto como contenido visual.</li></ul><p><strong>Desventajas de LLMs:</strong></p><ul><li><strong>Coste:</strong> Más caros en términos de recursos de cómputo y llamadas a APIs.</li><li><strong>Complejidad:</strong> Requieren más tiempo para la implementación y una mayor comprensión técnica.</li></ul><h3>Hands On: Comparativa entre OCR y LLMs</h3><p>Ahora, pasemos de la teoría a la práctica. Vamos a realizar un análisis comparativo entre el método tradicional de OCR y varios enfoques basados en LLMs, como Gemini 1.5 Flash y GPT-4o, para procesar documentos financieros.</p><h4>1. Método Tradicional de OCR</h4><p>Empezamos con el clásico OCR. Aquí utilizamos pdf2image para convertir PDFs a imágenes y pytesseract para realizar el reconocimiento de texto. Es cierto que se pueden utilizar aproximaciones más complejas con otros modelos de Machine Learning, <a href="https://medium.com/@jddam/digitalizando-tus-finanzas-de-im%C3%A1genes-o-pdfs-a-datos-estructurados-ocr-e894730cefeb">como el que vimos en el primer artículo</a>, capaces de identificar, por ejemplo las tablas y los elementos de una factura, y extraer esa información de una manera “más estructurada”, aunque sigue teniendo sus limitaciones:</p><pre>import time<br>from pdf2image import convert_from_path<br>import pytesseract<br>from PIL import Image<br><br>def ocr_process(pdf_path):<br>    start_time = time.time()<br>    <br>    # Convertir PDF a imagen<br>    pages = convert_from_path(pdf_path, 300)<br>    image = pages[0]<br>    <br>    # Realizar OCR<br>    text = pytesseract.image_to_string(image)<br>    <br>    end_time = time.time()<br>    processing_time = end_time - start_time<br>    <br>    return text, processing_time<br><br># Prueba<br>pdf_path = &quot;data/invoice_0.pdf&quot;<br>text, time_taken = ocr_process(pdf_path)<br>print(f&quot;Tiempo de procesamiento OCR: {time_taken:.2f} segundos&quot;)<br>print(f&quot;Caracteres extraídos: {len(text)}&quot;)<br>print(text)</pre><h4>2. Método Basado en Gemini 1.5 Flash</h4><p>Los modelos Gemini AI de Google, como Gemini 1.5 Flash, son LLMs multimodales que puede procesar tanto texto como imágenes, extrayendo datos estructurados directamente de documentos complejos:</p><pre>import time<br>from llama_index.multi_modal_llms.gemini import GeminiMultiModal<br>from llama_index.core.program import MultiModalLLMCompletionProgram<br>from llama_index.core.output_parsers import PydanticOutputParser<br>from pydantic import BaseModel<br>from llama_index.core.schema import ImageDocument<br>from PIL import Image<br>import os<br>import base64<br>from io import BytesIO<br>from pdf2image import convert_from_path<br><br>class InvoiceData(BaseModel):<br>    invoice_number: str<br>    total_amount: float<br><br>def image_to_base64(image):<br>    buffered = BytesIO()<br>    image.save(buffered, format=&quot;PNG&quot;)<br>    return base64.b64encode(buffered.getvalue()).decode(&quot;utf-8&quot;)<br><br>def pdf_to_images(pdf_path):<br>    return convert_from_path(pdf_path, 300)<br><br>def gemini_process(file_path):<br>    start_time = time.time()<br>    <br>    gemini_llm = GeminiMultiModal(api_key=&quot;YOUR_API_KEY&quot;, model_name=&quot;models/gemini-1.5-flash&quot;)<br>    <br>    if file_path.lower().endswith(&#39;.pdf&#39;):<br>        images = pdf_to_images(file_path)<br>    else:<br>        images = [Image.open(file_path)]<br>    <br>    results = []<br>    for image in images:<br>        # Convertir la imagen a base64<br>        image_base64 = image_to_base64(image)<br>        <br>        # Crear ImageDocument con la imagen en base64<br>        image_document = ImageDocument(<br>            image_path=file_path,<br>            image=image_base64<br>        )<br>        <br>        extraction_program = MultiModalLLMCompletionProgram.from_defaults(<br>            output_parser=PydanticOutputParser(InvoiceData),<br>            image_documents=[image_document],<br>            prompt_template_str=&quot;Extract invoice details from this image:&quot;,<br>            multi_modal_llm=gemini_llm,<br>        )<br>        <br>        result = extraction_program()<br>        results.append(result)<br>    <br>    end_time = time.time()<br>    processing_time = end_time - start_time<br>    <br>    return results, processing_time<br><br># Prueba<br>file_path = &quot;data/invoice_0.pdf&quot;<br>file_path = os.path.abspath(file_path)<br><br>results, time_taken = gemini_process(file_path)<br>print(f&quot;Tiempo de procesamiento Gemini: {time_taken:.2f} segundos&quot;)<br>for result in results:<br>    print(f&quot;Datos extraídos: {result}&quot;)</pre><h4>3. Método Basado en OpenAI GPT-4</h4><p>GPT-4o es uno de los modelos más avanzados para procesamiento de texto e imágenes. Vamos a ver cómo lo hace con una factura, utilizando la nueva funcionalidad de “Structured Outputs” anunciada recientemente:</p><pre>import time<br>from openai import OpenAI<br>import base64<br>from pdf2image import convert_from_path<br>import os<br>from PIL import Image<br>from io import BytesIO<br>import json<br><br>client = OpenAI()<br>MODEL = &quot;gpt-4o-2024-08-06&quot;<br><br>invoice_extractor_prompt = &#39;&#39;&#39;<br>    You are a helpful invoice information extractor. You will be provided with an image of an invoice,<br>    and your goal will be to extract the invoice number and total amount.<br>    Provide the extracted information in a structured format, including steps of your reasoning process.<br>&#39;&#39;&#39;<br><br>def encode_image(image):<br>    buffered = BytesIO()<br>    image.save(buffered, format=&quot;PNG&quot;)<br>    return base64.b64encode(buffered.getvalue()).decode(&#39;utf-8&#39;)<br><br>def pdf_to_images(pdf_path):<br>    return convert_from_path(pdf_path)<br><br>def get_invoice_info(image_content):<br>    response = client.chat.completions.create(<br>        model=MODEL,<br>        messages=[<br>            {<br>                &quot;role&quot;: &quot;system&quot;, <br>                &quot;content&quot;: invoice_extractor_prompt<br>            },<br>            {<br>                &quot;role&quot;: &quot;user&quot;, <br>                &quot;content&quot;: [<br>                    {<br>                        &quot;type&quot;: &quot;text&quot;, <br>                        &quot;text&quot;: &quot;Extract the invoice number and total amount from this image.&quot;<br>                    },<br>                    {<br>                        &quot;type&quot;: &quot;image_url&quot;,<br>                        &quot;image_url&quot;: {<br>                            &quot;url&quot;: f&quot;data:image/png;base64,{image_content}&quot;<br>                        }<br>                    }<br>                ]<br>            }<br>        ],<br>        response_format={<br>            &quot;type&quot;: &quot;json_schema&quot;,<br>            &quot;json_schema&quot;: {<br>                &quot;name&quot;: &quot;invoice_extraction&quot;,<br>                &quot;schema&quot;: {<br>                    &quot;type&quot;: &quot;object&quot;,<br>                    &quot;properties&quot;: {<br>                        &quot;invoice_number&quot;: {<br>                            &quot;type&quot;: &quot;string&quot;,<br>                            &quot;description&quot;: &quot;The number of the invoce&quot;,<br>                        },<br>                        &quot;total_amount&quot; : {<br>                            &quot;type&quot;: &quot;number&quot;,<br>                            &quot;description&quot;: &quot;The total amount of the invoice&quot;<br>                        }<br>                    },<br>                    &quot;required&quot;: [&quot;invoice_number&quot;, &quot;total_amount&quot;],<br><br>                    &quot;additionalProperties&quot;: False<br>                },<br>                &quot;strict&quot;: True<br>            }<br>        }<br>    )<br><br>    return response.choices[0].message<br><br>def gpt4_process(file_path):<br>    start_time = time.time()<br>    <br>    if file_path.lower().endswith(&#39;.pdf&#39;):<br>        images = pdf_to_images(file_path)<br>    else:<br>        images = [Image.open(file_path)]<br>    <br>    results = []<br>    for image in images:<br>        base64_image = encode_image(image)<br>        result = get_invoice_info(base64_image)<br>        results.append(result)<br>    <br>    end_time = time.time()<br>    processing_time = end_time - start_time<br>    <br>    return results, processing_time<br><br># Prueba<br>file_path = &quot;data/invoice_0.pdf&quot;<br>result, time_taken = gpt4_process(file_path)<br>print(f&quot;Tiempo de procesamiento GPT-4: {time_taken:.2f} segundos&quot;)<br>for invoice_info in result:<br>    print(f&quot;Datos extraídos: {invoice_info.content}&quot;)  </pre><h4>4. Método Basado en un LLM Open Source en ejecución local</h4><p>Como extra, he querido finalmente probar con un LLM en ejecución local. He utilizado el modelo open source Llama 3.1 de Meta vía Ollama. Este enfoque puede ser útil para quienes buscan evitar costes de API y mantener todo el procesamiento en casa:</p><pre>from llama_index.llms.ollama import Ollama<br><br>LLM_MODEL = &quot;llama3.1&quot;<br>OLLAMA_BASE_URL = &quot;http://localhost:11434&quot;<br><br>def image_to_text(image):<br>    return pytesseract.image_to_string(image)<br><br>def local_llm_process(file_path):<br>    start_time = time.time()<br>    llm = Ollama(model=LLM_MODEL, base_url=OLLAMA_BASE_URL, temperature=0)<br>    <br>    if file_path.lower().endswith(&#39;.pdf&#39;):<br>        images = pdf_to_images(file_path)<br>    else:<br>        images = [Image.open(file_path)]<br>    <br>    results = []<br>    for image in images:<br>        # Convertir la imagen a texto usando OCR<br>        image_text = image_to_text(image)<br>        <br>        prompt = f&quot;&quot;&quot;<br>        Extract the invoice number and total amount from the following invoice text:<br>        {image_text}<br><br>        Your response must be ONLY a valid JSON object with the following structure:<br>        {{&quot;invoice_number&quot;: &quot;string&quot;, &quot;total_amount&quot;: number}}<br><br>        Do not include any explanations or additional text. Only the JSON object is allowed in your response.<br>        If you cannot extract the information, return {{&quot;invoice_number&quot;: &quot;&quot;, &quot;total_amount&quot;: 0}}.<br>        &quot;&quot;&quot;<br>        <br>        response = llm.complete(prompt)<br>        results.append(response.text.strip())<br>    <br>    end_time = time.time()<br>    return results, end_time - start_time<br><br># Ejemplo de uso con una factura en la carpeta data<br>file_path = &quot;data/invoice_0.pdf&quot;<br>result, time_taken = local_llm_process(file_path)<br>print(f&quot;Tiempo de procesamiento LLM local: {time_taken:.2f} segundos&quot;)<br>for invoice_info in result:<br>    print(f&quot;Datos extraídos: {invoice_info}&quot;)</pre><p>En el siguiente <a href="https://github.com/albertgilopez/codigo-llm/tree/main/ocr-vs-llms"><strong>enlace</strong></a><strong> </strong>puedes descargar el código completo en Github.</p><p>Después de ejecutar los diferentes métodos, al comparar los resultados:</p><ul><li><strong>OCR tradicional</strong>: Muy rápido y económico, pero limitado en la capacidad de estructurar datos y entender el contexto.</li><li><strong>Gemini 1.5 Flash</strong>: Ofrece una buena velocidad y costes relativamente bajos, aunque no logró estructurar la información tan bien como esperábamos.</li><li><strong>GPT-4o</strong>: Proporciona la mejor precisión y estructuración de datos, pero a un coste significativamente mayor y con tiempos de procesamiento más largos.</li><li><strong>LLM local</strong>: Aunque es lento (y todo dependerá de la infraestructura), proporciona una estructuración precisa de datos sin costes de API, lo que lo hace ideal para quienes priorizan la privacidad y control total.</li></ul><p>En general, la elección entre OCR y LLMs depende en gran medida de tus necesidades:</p><ul><li><strong>OCR</strong> es ideal si necesitas procesar grandes volúmenes de documentos rápidamente y con un presupuesto ajustado.</li><li><strong>LLMs</strong> como GPT-4o o Gemini 1.5 Flash son la opción adecuada cuando la precisión y la capacidad de manejar documentos complejos son fundamentales, aunque con un coste mayor.</li><li><strong>LLMs locales</strong> ofrecen una opción interesante, proporcionando alta precisión sin costes de API, a cambio de tiempos de procesamiento más largos.</li></ul><p>En resumen, no hay una solución única que sirva para todo. La clave está en evaluar tus necesidades y recursos, y elegir la herramienta que mejor se adapte a tu situación.</p><h3>What’s Next: Próximos Pasos</h3><p><em>Como extra, he querido añadir otro artículo a la lista. Quiero desarrollar un caso de uso híbrido en la que la empresa FinTech Solutions S.A., una empresa líder en servicios financieros, implementó un innovador sistema híbrido de procesamiento de facturas utilizando diversas tecnologías de Inteligencia Artificial (IA) (próximamente).</em></p><ul><li><a href="https://medium.com/@jddam/digitalizando-tus-finanzas-de-im%C3%A1genes-o-pdfs-a-datos-estructurados-ocr-e894730cefeb"><strong>ARTÍCULO 1. Digitalizando tus Finanzas. De imágenes (o PDFs) a datos estructurados: OCR</strong></a></li><li><a href="https://medium.com/@jddam/digitalizando-tus-finanzas-de-im%C3%A1genes-o-pdfs-a-datos-estructurados-llms-e0460d50b200"><strong>ARTÍCULO 2. Digitalizando tus Finanzas. De imágenes (o PDFs) a datos estructurados: LLMs</strong></a></li><li><a href="https://medium.com/@jddam/digitalizando-tus-finanzas-de-im%C3%A1genes-o-pdfs-a-datos-estructurados-ocr-vs-llms-26515a3f2fe2"><strong>ARTÍCULO 3. Digitalizando tus Finanzas. De imágenes (o PDFs) a datos estructurados: OCR vs LLMs</strong></a></li></ul><p><strong>Comparte tu experiencia:</strong></p><p>Estoy abierto a colaborar y discutir sobre las posibilidades que ofrece la inteligencia artificial y cómo trabajar juntos para explorar y construir soluciones en diferentes sectores. Si tienes ideas, preguntas o simplemente quieres hablar de ello, escríbeme:</p><ul><li>GitHub: <a href="https://github.com/albertgilopez">https://github.com/albertgilopez</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/albertgilopez/">https://www.linkedin.com/in/albertgilopez/</a></li><li>M.IA, tu asistente financiero inteligente: <a href="https://himia.app/">https://himia.app/</a></li><li>Inteligencia Artificial Generativa en español: <a href="https://www.codigollm.es/">https://www.codigollm.es/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26515a3f2fe2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Digitalizando tus Finanzas. De imágenes (o PDFs) a datos estructurados: LLMs]]></title>
            <link>https://medium.com/@jddam/digitalizando-tus-finanzas-de-im%C3%A1genes-o-pdfs-a-datos-estructurados-llms-e0460d50b200?source=rss-3723dc84302b------2</link>
            <guid isPermaLink="false">https://medium.com/p/e0460d50b200</guid>
            <category><![CDATA[gemini-flash]]></category>
            <category><![CDATA[finance]]></category>
            <category><![CDATA[unstructured-data]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[invoice]]></category>
            <dc:creator><![CDATA[Albert Gil López]]></dc:creator>
            <pubDate>Sat, 10 Aug 2024 03:01:28 GMT</pubDate>
            <atom:updated>2024-08-19T06:25:28.733Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0WPv-hsNbODAWXoEjBc5Lw.jpeg" /><figcaption>AUTOR: DALL-E 3</figcaption></figure><p>Este es el segundo artículo de la saga. La inteligencia artificial generativa (IAG) ha cambiado la manera en que procesamos información y extraemos datos de documentos financieros. Si bien las técnicas tradicionales de OCR han sido fundamentales para la digitalización de documentos, los modelos de lenguaje (LLM) como Gemini 1.5 Flash de Google ofrecen nuevas posibilidades al proporcionar una comprensión más profunda del contexto de los documentos. En este artículo, te explicaré cómo utilizar LLMs para extraer información financiera crítica de documentos escaneados y cómo estas herramientas pueden superar algunas de las limitaciones del OCR tradicional.</p><h3>Background</h3><p>El uso de modelos de lenguaje grandes en el procesamiento de documentos financieros ofrece un enfoque más avanzado en comparación con el OCR tradicional. Los LLMs no solo reconocen caracteres y palabras, sino que también comprenden el contexto en el que se encuentran, permitiendo una interpretación más precisa de la información.</p><p>Los modelos como <strong>Gemini 1.5 Flash</strong> pueden interpretar y estructurar datos de documentos complejos, como facturas y recibos, transformando el texto sin formato en información valiosa estructurada, como <strong>JSON</strong>, que pueden ser fácilmente utilizados en aplicaciones y análisis de datos para la toma de decisiones empresariales. Esto es especialmente útil en aplicaciones de análisis financiero donde la precisión y la comprensión contextual son cruciales, tal y cómo ya lo estamos aplicando en <a href="https://himia.app/"><strong>M.IA</strong></a>.</p><p>La capacidad <strong>multimodal </strong>de estos modelos les permite manejar tanto texto como imágenes, lo cual es esencial para procesar facturas que pueden contener texto en formato de imagen, como anotaciones escritas a mano.</p><h3>Hands-on</h3><p>En este enfoque, utilizaremos un LLM para interpretar el texto de una imagen de una factura y devolver la información en un formato estructurado.</p><h4>Paso 1: Preparación de la imagen</h4><p>Antes de aplicar el modelo, necesitamos asegurarnos de que la imagen de la factura esté en un formato adecuado. Para este ejemplo, utilizaremos la imagen de una factura, como la siguiente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jMM4vob8KqUKb7OVOS-3kg.jpeg" /></figure><h4>Paso 2: Configuración del entorno</h4><p>Para utilizar el modelo Gemini 1.5 Flash de Google, debes tener acceso a la API y configurar tu entorno de desarrollo con la clave de API. Asegúrate de tener una cuenta en <strong>Google Cloud</strong> y seguir los pasos necesarios para obtener acceso a la <strong>API de Gemini</strong>.</p><pre>import google.generativeai as genai<br>import os<br><br># Configura tu clave de API<br>GOOGLE_API_KEY = &#39;TU_CLAVE_API&#39;<br>os.environ[&quot;GOOGLE_API_KEY&quot;] = GOOGLE_API_KEY<br>genai.configure(<br>    api_key=GOOGLE_API_KEY,<br>    client_options={&quot;api_endpoint&quot;: &quot;generativelanguage.googleapis.com&quot;},<br>)</pre><p><strong>Definición del modelo Pydantic</strong></p><p>Para estructurar los datos extraídos, utilizamos <strong>Pydantic</strong> para definir el esquema de los datos financieros que esperamos obtener de los documentos:</p><pre>from pydantic import BaseModel<br><br>class InvoiceItem(BaseModel):<br>    description: str<br>    quantity: float<br>    unit_price: float<br>    vat_percentage: float<br>    gross_worth: float<br><br>class InvoiceData(BaseModel):<br>    invoice_number: str<br>    date_of_issue: str<br>    seller_name: str<br>    seller_address: str<br>    seller_tax_id: str<br>    seller_iban: str<br>    client_name: str<br>    client_address: str<br>    client_tax_id: str<br>    items: list[InvoiceItem]<br>    net_worth: float<br>    vat: float<br>    total: float</pre><p><strong>Visualización de la imagen</strong></p><p>El primer paso es cargar la imagen del documento financiero que queremos procesar. Para este ejemplo, utilizaremos la factura escaneada que te he mostrado antes. Podemos utilizar matplotlib para visualizar la imagen de la factura y asegurarnos de que está correctamente cargada:</p><pre>from PIL import Image<br>import matplotlib.pyplot as plt<br><br># Ruta de la imagen de la factura<br>invoice_image_path = &#39;data/invoice_0_charspace_1.jpg&#39;<br><br># Cargar la imagen<br>image = Image.open(invoice_image_path).convert(&quot;RGB&quot;)<br><br># Mostrar la imagen<br>plt.figure(figsize=(8, 6))<br>plt.imshow(image)<br>plt.axis(&#39;off&#39;)<br>plt.show()</pre><p><strong>Extracción de datos utilizando LLMs</strong></p><p>Con la imagen cargada, utilizamos el modelo <strong>Gemini 1.5 Flash</strong> para extraer los datos financieros. Definimos un prompt que le indica al modelo qué información debe extraer y en qué formato debe devolverla.</p><pre>from llama_index.multi_modal_llms.gemini import GeminiMultiModal<br>from llama_index.core.program import MultiModalLLMCompletionProgram<br>from llama_index.core.output_parsers import PydanticOutputParser<br>from llama_index.core import SimpleDirectoryReader<br><br># Definir el prompt<br>prompt_template_str = &quot;&quot;&quot;\<br>    can you summarize what is in the image\<br>    and return the answer with json format \<br>&quot;&quot;&quot;<br><br># Cargar imágenes desde el directorio utilizando SimpleDirectoryReader<br># El modelo espera las imágenes en una ruta con en un formato específico <br>def load_images_from_directory(directory_path):<br>    &quot;&quot;&quot;Carga imágenes desde un directorio especificado.&quot;&quot;&quot;<br>    reader = SimpleDirectoryReader(directory_path)<br>    image_documents = reader.load_data()<br>    return image_documents<br><br># Asegúrate de que el directorio es correcto<br>directory_path = &quot;data/&quot;<br>image_documents = load_images_from_directory(directory_path)<br><br># Inicializar el modelo Gemini<br>try:<br>    gemini_pro = GeminiMultiModal(model_name=&quot;models/gemini-1.5-flash&quot;)<br>except Exception as e:<br>    print(f&quot;Error initializing Gemini model: {e}&quot;)<br>    raise<br><br># Función para la extracción de datos<br>def pydantic_gemini(model_name, output_class, image_documents, prompt_template_str):<br>    gemini_llm = GeminiMultiModal(api_key=GOOGLE_API_KEY, model_name=model_name)<br>    llm_program = MultiModalLLMCompletionProgram.from_defaults(<br>        output_parser=PydanticOutputParser(output_class),<br>        image_documents=image_documents,<br>        prompt_template_str=prompt_template_str,<br>        multi_modal_llm=gemini_llm,<br>        verbose=True,<br>    )<br>    response = llm_program()<br>    return response<br><br># Ejecutar la extracción de datos<br>try:<br>    invoice_data_response = pydantic_gemini(<br>        &quot;models/gemini-1.5-flash&quot;,<br>        InvoiceData,<br>        image_documents,<br>        prompt_template_str,<br>    )<br><br>    # Mostrar los resultados<br>    for response in invoice_data_response:<br>        print(response)<br>except Exception as e:<br>    print(f&quot;An error occurred: {e}&quot;)</pre><p>En este código, definimos un proceso para extraer datos de una imagen de factura utilizando un modelo de lenguaje multimodal de Google. El modelo interpreta la imagen, extrae la información relevante y la estructura en un formato JSON fácil de manejar.</p><p>El resultado:</p><pre>(&#39;invoice_number&#39;, &#39;12060439&#39;)<br>(&#39;date_of_issue&#39;, &#39;08/29/2020&#39;)<br>(&#39;seller_name&#39;, &#39;Brown-Johnson&#39;)<br>(&#39;seller_address&#39;, &#39;310 Amanda Corner Suite 472\nNorth William, MN 33119&#39;)<br>(&#39;seller_tax_id&#39;, &#39;981-94-7235&#39;)<br>(&#39;seller_iban&#39;, &#39;GB78IXYES8273701690538&#39;)<br>(&#39;client_name&#39;, &#39;Calderon-Duran&#39;)<br>(&#39;client_address&#39;, &#39;9884 Roberts Tunnel\nNorth Lindaside, VA 02674&#39;)<br>(&#39;client_tax_id&#39;, &#39;996-81-8911&#39;)<br>(&#39;items&#39;, [InvoiceItem(description=&#39;Rectangle Area Rug Wood Grain Carpet Mat for Living Room Bedroom - 180x60cm&#39;, quantity=4.0, unit_price=32.81, vat_percentage=10.0, gross_worth=144.36), InvoiceItem(description=&#39;Rug for living room-Minion And Banana Area Rugs Living Room Carpet, Christmas...&#39;, quantity=2.0, unit_price=29.96, vat_percentage=10.0, gross_worth=65.91), InvoiceItem(description=&quot;Yilong 5&#39;x7.5&#39; Hand Knotted Area Rug Medium Size Classic Floor Carpets 0186&quot;, quantity=3.0, unit_price=2800.0, vat_percentage=10.0, gross_worth=9240.0)])<br>(&#39;net_worth&#39;, 8591.16)<br>(&#39;vat&#39;, 859.12)<br>(&#39;total&#39;, 9450.28)</pre><p>Bueno. No quería cerrar el artículo sin la última actualización de OpenAI que ya ha cambiado el juego en cuanto a la fiabilidad y la precisión de los LLMs para la extracción de datos estructurados: la introducción de <em>Guaranteed Structured Outputs</em>. Esta nueva funcionalidad, <a href="https://openai.com/index/introducing-structured-outputs-in-the-api/">anunciada recientemente por OpenAI</a>, asegura que la salida de los modelos de lenguaje se adhiera estrictamente a un formato JSON definido previamente, garantizando así que los datos extraídos se presenten siempre de manera estructurada y coherente.</p><p>En nuestro caso, con M.IA, esta actualización es muy relevante para la extracción de datos financieros a partir de documentos complejos, ya que elimina una de las mayores incertidumbres al utilizar LLMs: la posibilidad de obtener respuestas no estructuradas o inconsistentes. Ahora, con el uso de un esquema JSON definido, podemos estar seguros de que los datos extraídos se integrarán de manera precisa y directa en nuestros sistemas de análisis o en cualquier pipeline de datos existente.</p><p>Por ejemplo, imgine que estás procesando un conjunto de facturas escaneadas, y necesitas que cada campo de datos se capture con exactitud para integrarlo en tu software de contabilidad. Con los <em>Structured Outputs</em> de OpenAI, puedes definir un esquema JSON que refleje exactamente cómo deben ser los datos de salida, asegurando que todos los valores, desde el número de factura hasta el importe total, se alineen con la estructura que tu sistema necesita.</p><p>Además, esta capacidad no solo es útil para facturas, sino también para otros documentos financieros como estados de cuenta, informes de gastos, y más, donde la consistencia y precisión de los datos es crítica.</p><p>Ahora, una vez que ya hemos extraído los datos, podemos realizar un análisis más profundo y visualizarlos para obtener insights adicionales.</p><ul><li><strong>Podemos visualizar los datos extraídos en gráficos para obtener insights adicionales.</strong> Utilizando herramientas como matplotlib, podemos crear gráficos de barras que muestren los gastos por artículo o comparar ventas actuales con datos históricos para detectar tendencias.</li><li>Los LLMs también nos permiten detectar <strong>anomalías </strong>en los datos financieros. Podemos comparar el total actual de una factura con datos históricos para identificar valores atípicos y potencialmente fraudulentos. Esto es especialmente útil para mantener la integridad de los datos y garantizar la precisión de la información financiera.</li><li>Finalmente, podemos convertir los datos extraídos a un DataFrame de Pandas y <strong>exportarlos a CSV</strong>. Esto facilita la integración de los datos en sistemas empresariales y análisis más avanzados, proporcionando una visión completa de la información financiera.</li></ul><h3>Conclusiones</h3><p>El uso de modelos de lenguaje grande (LLMs) como Gemini 1.5 Flash para la extracción de datos financieros ofrece un enfoque más flexible y preciso que las técnicas tradicionales de OCR. Los LLMs no solo interpretan texto, sino que comprenden el contexto de los documentos, lo que les permite extraer información relevante de manera más precisa. Este enfoque es especialmente útil para documentos financieros que contienen información compleja y variada.</p><p>Además, la reciente introducción de los <em>Structured Outputs</em> por parte de OpenAI refuerza aún más la confiabilidad de estos modelos, garantizando que los datos extraídos se presenten siempre en un formato estructurado y consistente, lo que es crucial para su integración en sistemas de análisis y aplicaciones empresariales.</p><p>Los LLMs representan un avance significativo en el procesamiento de documentos, proporcionando una comprensión más profunda y detallada del contenido de los documentos financieros. Esto no solo mejora la precisión de la extracción de datos, sino que también abre nuevas posibilidades para el análisis de documentos en tiempo real y la integración de estos datos en aplicaciones de inteligencia empresarial.</p><h4>What’s Next: próximos pasos</h4><p>En el tercer artículo de esta serie, haré una comparación detallada entre los enfoques basados en OCR y los modelos de lenguaje (LLMs) para la extracción de datos financieros. Analizaremos las ventajas y desventajas de cada método, considerando factores como la precisión, eficiencia, coste y facilidad de implementación. Esta comparación espero que te pueda servir para elegir la mejor herramienta para tus necesidades y aprovechar al máximo todo el potencial de tus datos financieros.</p><ul><li><a href="https://medium.com/@jddam/digitalizando-tus-finanzas-de-im%C3%A1genes-o-pdfs-a-datos-estructurados-ocr-e894730cefeb"><strong>ARTÍCULO 1. Digitalizando tus Finanzas. De imágenes (o PDFs) a datos estructurados: OCR</strong></a></li><li><a href="https://medium.com/@jddam/digitalizando-tus-finanzas-de-im%C3%A1genes-o-pdfs-a-datos-estructurados-llms-e0460d50b200"><strong>ARTÍCULO 2. Digitalizando tus Finanzas. De imágenes (o PDFs) a datos estructurados: LLMs</strong></a></li><li><a href="https://medium.com/@jddam/digitalizando-tus-finanzas-de-im%C3%A1genes-o-pdfs-a-datos-estructurados-ocr-vs-llms-26515a3f2fe2"><strong>ARTÍCULO 3. Digitalizando tus Finanzas. De imágenes (o PDFs) a datos estructurados: OCR vs LLMs</strong></a></li></ul><p><strong>Comparte tu experiencia:</strong></p><p>Estoy abierto a colaborar y discutir sobre las posibilidades que ofrece la inteligencia artificial y cómo trabajar juntos para explorar y construir soluciones en diferentes sectores. Si tienes ideas, preguntas o simplemente quieres hablar de ello, escríbeme:</p><ul><li>GitHub: <a href="https://github.com/albertgilopez">https://github.com/albertgilopez</a></li><li>LinkedIn: <a href="https://www.linkedin.com/in/albertgilopez/">https://www.linkedin.com/in/albertgilopez/</a></li><li>M.IA, tu asistente financiero inteligente: <a href="https://himia.app/">https://himia.app/</a></li><li>Inteligencia Artificial Generativa en español: <a href="https://www.codigollm.es/">https://www.codigollm.es/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e0460d50b200" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>