Una popular herramienta de GitHub acaba de resolver el mayor problema de los agentes de IA
AAI LABS
컴퓨터/소프트웨어
스크립트
00:00:00si trabajas con buenos modelos como Opus y GPT 5.6, normalmente obtendrás buenos resultados, pero estos modelos
00:00:06también consumen muchísimos tokens, y la situación empeora aún más con los de gama alta como GPT Astra
00:00:11y Fable 5.1, ya que alcanzarás tu límite de uso mucho más rápido que con otros modelos.
00:00:16También son muy lentos, por lo que terminas esperando demasiado tiempo a que termine una sola tarea. Para solucionar
00:00:21este problema exacto, hay una herramienta que ha estado ganando popularidad en GitHub últimamente llamada Graft; arregla la forma
00:00:26en que estos agentes manejan los proyectos por defecto. No solo te ahorra tokens, sino que también hace que el
00:00:31agente sea mucho más rápido que cuando trabaja por su cuenta, y tiene una forma de funcionar muy interesante que
00:00:36soluciona la razón principal por la que ocurre este problema en primer lugar. No es que no existan ya
00:00:40herramientas diseñadas para resolver este problema, pero todas tienen un gran vacío, y eso es exactamente lo que esta herramienta corrige.
00:00:46Si es tu primera vez por aquí, somos una empresa de software y este es nuestro canal, AI Labs. En este
00:00:51vídeo te vamos a mostrar exactamente cómo Graft hace que usar estos modelos sea más económico. Pero antes de entrar
00:00:56en Graft, necesitas entender por qué tu agente usa tantos tokens antes de cambiar nada en
00:01:02tu aplicación. El método predeterminado que usan agentes como Claude Code y Codex para encontrar archivos tiene un problema.
00:01:07Cuando le pides al agente que añada algo a la aplicación en la que estás trabajando, primero necesita encontrar las partes
00:01:12de tu aplicación donde debe escribir ese cambio. Para encontrar esas partes, utiliza diferentes comandos en la
00:01:17terminal que buscan palabras relacionadas con lo que quieres añadir. Los modelos no suelen encontrar lo que
00:01:23buscan al primer intento; tienen que usar múltiples herramientas para acotar qué es exactamente
00:01:28lo que están buscando, y cada vez que el modelo necesita decir qué herramienta usar a continuación, el agente
00:01:32le envía al modelo toda vuestra conversación hasta el momento, incluidas las respuestas de las herramientas que ya
00:01:37ha utilizado. El modelo lee todo eso para decidir su próximo paso, por lo que llega al archivo correcto
00:01:42después de múltiples turnos, y cada uno de esos turnos te cuesta uso. Por ejemplo, cuando le pides al agente que haga
00:01:47un botón verde, primero necesita encontrar qué archivo contiene siquiera el código de ese botón, así que busca
00:01:53el archivo que contiene ese botón y los resultados van al modelo junto con tu mensaje; luego el agente
00:01:58usa otra herramienta para leer las líneas específicas de código de ese archivo, y solo después de eso realmente
00:02:04hace el cambio. Ese toma y daca es cómo se realiza cada cambio que solicitas, ya que todos tus
00:02:08mensajes y resultados de herramientas se envían una y otra vez, haciendo que la ventana de contexto siga creciendo. No solo te está
00:02:14costando contexto, sino que también está ralentizando al modelo, porque de esta manera el modelo está usando múltiples turnos
00:02:19para acotar el archivo requerido, por lo que cada nueva búsqueda añade más información y el modelo tiene que usar
00:02:25tokens para decidir qué hacer con ella. Esa es en realidad una de las razones por las que alcanzas tu límite de uso cuando
00:02:30trabajas con agentes en muchas tareas en una sola sesión. Ahora bien, alcanzar el límite de uso es solo una
00:02:36consecuencia; también obtienes peores resultados de calidad porque hay tantas cosas en la ventana de contexto que
00:02:41el agente no puede concentrarse en una sola cosa a la vez. Como este es un problema conocido, ya hay herramientas
00:02:46por ahí que intentan resolverlo. Un enfoque común que utilizan estas herramientas es convertir secciones de tu
00:02:51código en números llamados vectores para que el modelo pueda compararlos fácilmente. Cuando haces una pregunta, la
00:02:56herramienta de búsqueda convierte la pregunta en vectores también y luego encuentra las secciones con las coincidencias más cercanas.
00:03:02Eso se llama búsqueda vectorial, lo que básicamente significa encontrar información según cuán similar sea su significado
00:03:07a lo que preguntaste. Pero la similitud por sí sola no te dice cómo se conectan las partes de tu aplicación; por
00:03:12ejemplo, el código para crear una cuenta y el para eliminar una cuenta pueden coincidir con una pregunta sobre
00:03:17cuentas, pero hacen dos cosas totalmente opuestas, por lo que elegir la incorrecta sería muy costoso.
00:03:21Es por eso que esta búsqueda no es tan efectiva y la mayoría de los agentes de programación no la usan en absoluto.
00:03:26Pero antes de pasar a la herramienta, sería genial que te suscribieras al canal y le dieras al botón
00:03:30de me gusta; este pequeño gesto de apoyo significa mucho para nosotros. Ahora bien, Graft es en realidad un comando de terminal
00:03:36que instalas en tu ordenador y está creado para cambiar el método predeterminado que usa tu agente de programación
00:03:41para que no tenga que abrirse camino buscando a través de tu proyecto antes de cada cambio. Hace esto
00:03:46construyendo un grafo de conocimiento, que es básicamente un mapa de todas las partes de tu proyecto, y muestra cómo
00:03:51se conectan las diferentes partes. El agente usa ese mapa para encontrar el código que necesita y comprobar qué otras partes
00:03:57dependen de él. De hecho, es gratuito y de código abierto, y la parte principal es que no utiliza modelos
00:04:02con una clave de API separada, por lo que funciona con tu suscripción habitual. También hay un paso opcional que utiliza
00:04:07un modelo para escribir páginas sencillas sobre tu aplicación que explican qué hace cada parte del código y cómo
00:04:12encajan las piezas. Realmente no lo necesitas porque el mapa ya le dice al agente qué se conecta con
00:04:17qué; este paso simplemente añade una explicación de lo que hace el código. Así que con esas páginas el agente llega
00:04:22a saber qué hace cada parte en lugar de abrir cada archivo. Cuando el equipo detrás de Graft probó esta herramienta,
00:04:28descubrieron que hace que los agentes sean cuatro veces más baratos en términos de uso de tokens, y ese es su mejor caso.
00:04:33En su propia prueba comparativa a lo largo de 162 ejecuciones, las tareas tomaron un 60 por ciento menos de tiempo en promedio, el agente usó sus herramientas un 46 por ciento menos
00:04:42de veces, un 42 por ciento menos de tokens y el costo resultó ser un 32 por ciento menor en promedio. Y dado que el ahorro
00:04:48proviene de todas las búsquedas que el agente ya no tiene que hacer, compensa más en un proyecto grande porque
00:04:53en un proyecto pequeño no hay muchas búsquedas que ahorrar para empezar. Graft funciona con Claude Code
00:04:58y Codex, así como con otros agentes de programación que utilizan comandos de terminal o MCP, pero el mapa que construye
00:05:04no es como la búsqueda vectorial de la que hablamos antes, porque Graft no convierte tu código en números y
00:05:09lo empareja por similitud; lee el código y anota qué parte utiliza realmente a cuál. Así que cuando
00:05:14cambias una parte, el agente puede ver exactamente qué más podría romper ese cambio, y cuando tu código cambia,
00:05:20simplemente actualiza las partes que cambiaron en lugar de construir todo de nuevo, por lo que el mapa se mantiene actualizado
00:05:25por sí solo y el agente nunca trabaja con una versión antigua de tu proyecto. Pero primero, escuchemos unas
00:05:30palabras de nuestro patrocinador, Hydra. Así que estábamos añadiendo una función de generación por IA a nuestra aplicación, lo que solía significar
00:05:35encargarte tú mismo de lidiar con los modelos, la infraestructura y las colas de trabajos por tu cuenta. Ahí es donde entra la API de Hydra;
00:05:41han construido todo el tiempo de ejecución y la API detrás de sus modelos, por lo que en lugar de levantar toda esa infraestructura tú mismo,
00:05:46toda esa capa ya está gestionada para ti. Hicimos una llamada real desde nuestro código y, en lugar de que aparezca un recurso sin más,
00:05:51recuperamos un trabajo real que podíamos rastrear, y vimos cómo pasaba de en cola a procesando y a
00:05:56completado antes de que llegara el contenido multimedia. Ese informe de estado es la parte que importa porque es cómo sabes
00:06:02que esto puede manejar trabajo real de producción. Solo se necesita un poco de código para integrarlo en tu propia aplicación, y hay
00:06:07una CLI y un SDK también para que puedas trabajar directamente desde tu terminal o editor. Este es el tipo de cosas que un desarrollador solitario
00:06:13simplemente no podía construir antes. Prueba Hydra gratis en hydra.com y usa nuestro código para obtener un 50 por ciento de descuento en tu
00:06:19primer mes. El enlace y el código están en la descripción de abajo. Antes de instalar nada, necesitas ver
00:06:24cómo Graft crea realmente ese mapa. Cuando lo usas para construir el mapa, Graft lee el código en tu
00:06:29ordenador y anota cada parte que encuentra con su nombre y dónde está en el proyecto;
00:06:34luego anota qué partes están conectadas con cuáles. Cada parte en ese mapa se llama nodo, y
00:06:39cada conexión entre dos partes se llama borde. Así que cuando el agente pregunta qué usa una parte en particular
00:06:44de tu aplicación, Graft sigue esos bordes y le da el código que está conectado a lo que estaba buscando
00:06:49para que pueda ver si ese cambio afecta a cualquier otra cosa, lo cual es exactamente lo que la búsqueda vectorial
00:06:53no podía hacer. Graft guarda ese mapa en tu ordenador como un archivo JSON. La razón por la que lo guarda como JSON es
00:06:59porque ese formato te permite escribir algo en una estructura adecuada con detalles adjuntos. También
00:07:04tiene un visor que se abre en tu navegador donde puedes ver el mapa y explorar las conexiones. Cuando
00:07:10Graft está conectado a Claude Code, le da al modelo las instrucciones para usar el mapa al inicio de
00:07:15cada sesión. Luego, cada vez que envías un mensaje, Graft comprueba las palabras de tu mensaje con el mapa y
00:07:20adjunta hasta tres ubicaciones coincidentes, por lo que el modelo ya sabe qué archivos y líneas debe leer
00:07:26antes de usar una sola herramienta. El código en sí solo entra en el contexto cuando el agente lee esas líneas,
00:07:32por lo que el modelo llega al archivo correcto en menos turnos y se añade mucho menos a la ventana de contexto,
00:07:37así que es más rápido y consume menos de tu límite. También hay una opción de MCP, y la diferencia es quién
00:07:43inicia la búsqueda. Con la configuración que acabamos de ver, Graft adivina a partir de tu mensaje y adjunta esas ubicaciones
00:07:48a cada mensaje, lo necesitara el agente o no. Con el MCP, no se adjunta nada a tus
00:07:53mensajes y el agente le pide a Graft solo cuando realmente necesita algo. En las propias pruebas de Graft,
00:07:58la versión de MCP acertó unas cuantas respuestas más que la versión de CLI, y la versión de CLI era más rápida. Cuando
00:08:04lo instalas, en realidad obtienes ambas cosas, y a medida que cambias tu aplicación, Graft mantiene el mapa actualizado por sí mismo. Antes
00:08:10de responder una pregunta, comprueba si el código ha cambiado desde que se construyó el mapa, y si es así,
00:08:15actualiza el mapa primero sin usar el modelo. Ahora, para instalar Graft, debes ir a su sitio web, que
00:08:20enlazaremos en la descripción, y desde allí puedes copiar el comando de instalación o copiar el mensaje de configuración
00:08:25para el agente de programación que estés usando y pegar eso directamente en el agente. Ese mensaje de configuración
00:08:30tiene todos los comandos que el agente necesita para instalar Graft y configurarlo en tu proyecto, y si prefieres
00:08:35hacer esa parte tú mismo, puedes hacerlo copiando el comando de instalación del sitio y ejecutándolo en la
00:08:40terminal desde cualquier carpeta. Una vez instalado, la CLI está lista para usar. Para usarla en un proyecto,
00:08:46necesitas configurar Graft en ese proyecto ejecutando el comando init. Este comando tiene que ejecutarse en la terminal
00:08:52porque añade algunas instrucciones para ese proyecto dentro de la carpeta
00:08:57que se perderían si lo ejecutas en otro lugar cuando lo ejecutas pregunta qué agente de código estás usando
00:09:02porque cada agente necesita su propia configuración y como estábamos usando claude code lo seleccionamos y
00:09:07procedimos con la instalación una vez hecho esto verás una habilidad de graft en la carpeta de tu proyecto
00:09:11que le indica al agente cómo usar graft y qué comandos tiene también instala ganchos y si
00:09:16no sabes qué es un gancho es un pequeño script que se ejecuta solo en un punto determinado estos ganchos obligan
00:09:22al agente a seguir el flujo de trabajo de graft hay múltiples ganchos que se instalan uno le da al
00:09:26modelo instrucciones para usar el mapa cuando comienza una sesión otro adjunta las ubicaciones coincidentes a cada
00:09:31indicación que envías y el último se ejecuta después de que claude edita un archivo para que el mapa se mantenga actualizado luego
00:09:37si estás configurando esto en un proyecto en el que ya has estado trabajando debes ejecutar el comando graft build
00:09:41en esa misma carpeta para que graft revise todo el código que ya está ahí y
00:09:46construya el mapa a partir de él y si estás comenzando en una carpeta vacía todavía no hay nada que mapear por lo que el
00:09:50skill hace que claude lo construya una vez que haya archivos a partir de ahí simplemente ejecutas claude code normalmente y el
00:09:56visor de mapas muestra los nodos y bordes que creó graft en una carpeta vacía el mapa comienza en cero nodos y
00:10:01graft los añade a medida que se crean los archivos ahora probamos graft construyendo una aplicación de reservas y
00:10:06agendamiento similar a calendly pero para proveedores independientes con fable 5.1 dado que este modelo consume tokens
00:10:13muy rápidamente no queríamos que gastara esfuerzo en las tareas incorrectas por eso tomamos una serie de
00:10:18pasos antes de trabajar con él primero escribimos un prd que es el documento que establece lo que la aplicación se
00:10:23supone que debe hacer para que conozca cada función que la aplicación necesita también añadimos un archivo claude.md que contiene
00:10:29instrucciones adaptadas para este modelo para permitirle funcionar durante turnos largos sin desviarse del objetivo ese
00:10:34archivo claude.md es el que subimos como plantilla en nuestra comunidad ai labs pro así que usamos esa misma
00:10:40plantilla primero le pedimos que llenara los vacíos en ese claude.md a partir del prd porque el archivo era solo
00:10:46una plantilla y si no tienes un prd puedes simplemente indicarle en tu instrucción qué estás construyendo en su lugar
00:10:51una vez actualizado el claude.md cambiamos el modelo a fable 5.1 y le dimos la instrucción de construir
00:10:57la aplicación de reservas junto con las herramientas con las que queríamos que se construyera la aplicación y debes decirle a este modelo
00:11:02explícitamente que está trabajando por su cuenta lo cual cubrimos en nuestro video anterior de fable 5.1 así que le dijimos
00:11:07que no se detuviera a pedir permiso con graft la compilación tomó 39 minutos y usó alrededor del 31 de la
00:11:14ventana de contexto sin graft la misma compilación tomó 47 minutos y usó alrededor del 35 por ciento y ambas aplicaciones
00:11:20prácticamente tenían la misma funcionalidad así que en esa primera compilación la diferencia fue pequeña porque el
00:11:25grafo no estaba construido en este punto pero se volvió más grande una vez que empezamos a hacer cambios porque para entonces graft
00:11:30ya tenía un mapa de todo el proyecto para buscar una renovación completa de la página de aterrizaje tomó menos de
00:11:35dos minutos y sin graft el mismo cambio habría tomado mucho más tiempo que eso después del cambio
00:11:40graft actualizó el mapa con los nuevos archivos y mostró su propia estimación de los tokens que ahorró en
00:11:46ese turno y hay una última cosa que debes saber cuando estás trabajando en un proyecto real
00:11:50no siempre incluye solo código sino que también contiene otros archivos que dan a los agentes contexto sobre lo que se está
00:11:56construyendo estos incluyen el prd todos tus archivos específicos de área el archivo learnings.md y muchos otros pero
00:12:03graft solo mapea código por lo que no mapea tu prd ni las notas lo que significa que el agente usa el método
00:12:09predeterminado habitual cuando tiene que leerlos y aparte de eso a mucha gente como nosotros le gusta usar claude code
00:12:14para muchas tareas que no son de código también así que para hacer que la herramienta se adapte a esas también la modificamos
00:12:20un poco para poder usarla en nuestros proyectos reales donde tenemos múltiples archivos de planes y hemos agregado
00:12:25esa versión en ai labs pro que es nuestra comunidad así que si encuentras valor en lo que hacemos y quieres
00:12:31apoyar el canal esta es la mejor forma de hacerlo el enlace está en la descripción esto nos lleva al final de
00:12:36este video si deseas apoyar el canal y ayudarnos a seguir haciendo videos como este puedes hacerlo
00:12:41usando el botón de super thanks abajo como siempre gracias por ver y nos vemos en el próximo
커뮤니티 글
아직 글이 없습니다. 이 영상에 대한 첫 번째 글을 작성해 보세요!
이 영상에 대해 글쓰기