Cómo Crear un Agente de IA con Python y LangChain (Tutorial con Gemini)

DevOps & AI: De "Chatear" a Construir Agentes Autónomos En esta guía aprenderás a crear un AI Agent en Python usando LangChain y Gemini.

Actualmente, existe una brecha enorme entre "chatear" con un modelo y construir una solución autónoma. En mi proyecto DevOpsTechIA, hemos explorado cómo transformar una simple instrucción en un flujo de trabajo real. No se trata solo de escribir un buen prompt; se trata de arquitectura.

📑 Índice de Temas

1. Las Tres Capas de la Inteligencia Artificial
2. Construimos el Agente
3. ¿Para qué usamos LangChain?
4. Preparación del Terreno
5. Ejecución del Agente
6. Anatomía de mi_agente.py
7. Acceso y Escalabilidad: De AI Studio a Vertex AI
8. Modelos: ¿Qué motores tenemos bajo el capó?
9. Desafíos y lecciones: Resolviendo el "Mundo Real"
10. Conclusión: El Futuro del Flujo de Trabajo Agéntico

Las Tres Capas de la Inteligencia Artificial

Para que una IA deje de ser un juguete y pase a ser una herramienta de ingeniería, debemos entender sus tres componentes fundamentales:

• El Prompt (La Intención): Es el conjunto de instrucciones en lenguaje natural que guía al modelo.

• Los Skills o Tools (El Músculo): Funciones de Python que permiten a la IA interactuar con el sistema de archivos o APIs externas.

• El Agente (El Cerebro): El orquestador que decide qué herramienta usar basándose en el razonamiento lógico.

Vamos a bajarlo a tierra con una analogía clara: Imagina que estás armando un equipo para tu proyecto "DevOpsTechIA".

1. El Prompt (La Instrucción)

Es el mensaje o la orden que le das al modelo. Es el "qué" quieres que haga.

• Ejemplo: "Escribe un artículo sobre Docker para principiantes".

• En la analogía: Es la receta de cocina que dejas escrita en un papel. Si la receta es buena, el plato sale bien; si es mala, el plato sale quemado.

• Nivel: Estático. Tú escribes, el modelo responde y ahí termina la interacción.

2. Los Skills o Herramientas (La Capacidad)

En el contexto de agentes, un "Skill" (o Tool) es una función específica que el modelo sabe usar para interactuar con el mundo real. La IA por sí sola solo sabe "hablar", los skills le dan "manos".

• Ejemplos: Buscar en Google, leer un archivo PDF, ejecutar un comando en la terminal, o consultar una base de datos.

• En la analogía: Son los utensilios de cocina (el cuchillo, la licuadora, el horno). Sin ellos, el chef solo puede imaginar la comida, pero no puede picar ni cocinar nada.

• Nivel: Ejecutable. Son pequeñas piezas de código (Python o nodos en n8n) que hacen una tarea concreta.

3. El Agente en Python (El Director de Orquesta)

El Agente es el sistema inteligente que decide qué prompts usar y qué skills activar para cumplir un objetivo complejo. No es solo un mensaje, es un programa que "piensa" y actúa en bucle.

• Ejemplo: Un script que busca las últimas noticias de IA (Skill 1), resume el contenido (Prompt), y luego lo publica en un blog (Skill 2). Si algo falla, el agente decide reintentarlo.

• En la analogía: Es el Chef. El Chef lee la receta (Prompt), usa el cuchillo (Skill) y si ve que la salsa está salada, decide (Razonamiento) no servir el plato y volver a empezar.

• Nivel: Dinámico e Autónomo. Es el "cerebro" que orquestas con código.

Los "skills" (que en programación de agentes solemos llamar Tools o Herramientas) no se "compran" en una tienda física, sino que se obtienen de tres fuentes principales dependiendo de qué tan complejo sea lo que quieras hacer.

Aquí te explico dónde se consiguen:

1. Los que ya vienen "de fábrica" (Frameworks)

Si usas frameworks como CrewAI o LangChain en tu máquina local, ellos ya tienen librerías de herramientas listas para usar. Solo tienes que importarlas.

• Ejemplos: Herramientas para leer archivos PDF, buscar en Wikipedia, hacer cálculos matemáticos o navegar por la web.
• Dónde están: En la documentación oficial de estos frameworks (ej. crewai_tools o langchain.tools).

2. Los que tú mismo programas (Custom Tools)

Esta es la parte más potente. Cualquier función que escribas en Python puede ser un skill. Si tu agente necesita, por ejemplo, consultar una base de datos específica de tu empresa o conectarse a un servidor por SSH:

• Cómo se consiguen: Tú escribes el código en Python que hace la tarea.
• El "truco": Le añades un "decorador" (un pequeño código encima de la función) que le explica a la IA para qué sirve esa función. Así, la IA sabe cuándo "llamar" a ese skill.

3. Los que vienen de APIs externas (Marketplaces de servicios)

Muchos skills dependen de servicios de terceros que conectas a tu código.

• Búsqueda en Google: Usas la API de Serper.dev o Google Search API.
• Enviar correos: Usas la API de Gmail o SendGrid.
• Análisis de datos: Usas la API de Wolfram Alpha.
• Dónde se consiguen: Te registras en esas webs, obtienes una "API Key" (una llave) y la pones en tu código de Python.

En esta guia vamos a construir un agente

CONSTRUIMOS EL AGENTE

El Rol de mi_agente.py: Propósito y Objetivo

El script mi_agente.py no es simplemente un conjunto de líneas de código; es el núcleo ejecutor que transforma la teoría en resultados tangibles. Su propósito principal es actuar como un puente operativo entre la capacidad de razonamiento de un modelo de lenguaje de última generación y las tareas prácticas de ingeniería en un sistema local.

Mientras que una interfaz de chat convencional se limita a ofrecer respuestas textuales, este script permite que la inteligencia artificial "salga de la caja" y realice acciones concretas.

El objetivo fundamental es la orquestación autónoma de la documentación técnica. Para lograrlo, el script se diseñó con tres metas claras:

1. Cerrar la brecha entre razonamiento y ejecución: El script faculta al modelo para que no solo sepa qué comando de instalación se necesita (como para Terraform o Docker), sino que sea capaz de hacer algo con esa información de manera inmediata.

2. Garantizar la persistencia y el orden: El objetivo no es solo obtener una respuesta, sino convertirla en un activo digital. mi_agente.py automatiza la creación de archivos Markdown, asegurando que el conocimiento técnico recolectado se guarde con un formato limpio, estructurado y listo para ser utilizado en un entorno profesional.

3. Reducir la intervención manual: Al integrar un ciclo de pensamiento y acción (ReAct), el script minimiza la necesidad de que un humano copie, pegue o formatee datos. El agente identifica la herramienta necesaria, procesa la información y genera el resultado final por sí solo, funcionando como un asistente de DevOps que entiende y ejecuta instrucciones complejas.

¿Por qué usaremos Python y no solo Prompt Engineering?

Si solo usáramos un prompt, la IA nos daría el comando de Terraform, pero nosotros tendríamos que copiarlo y pegarlo en un archivo manualmente.

Al usar un Agente en Python, logramos que:

1. La IA busque el comando.
2. La IA detecte si el comando es correcto.
3. La IA cree el archivo .md en nuestro sistema de archivos automáticamente.

¿Por qué lo usamos en nuestro proyecto?

Sin LangChain, tendrías que escribir cientos de líneas de código manual para manejar la conexión con la API, formatear las respuestas y controlar los errores. LangChain lo organiza todo en piezas que puedes conectar:

1. Componentes (Las piezas de LEGO)

LangChain divide las tareas en módulos. En tu script mi_agente.py, estás usando varios:

• Modelos (LLMs): El conector para hablar con Gemini.
• Prompts: Plantillas para estructurar cómo le pides las cosas a la IA.
• Tools (Herramientas): Funciones de Python (como tu buscador de comandos) que la IA puede decidir usar.

2. Cadenas (Chains)

Es la capacidad de unir varios pasos. Por ejemplo: "Primero busca el comando, luego pásalo a la función de guardado y finalmente confírmame que está listo". LangChain se encarga de que la información fluya de un paso al otro automáticamente.

3. Agentes (El nivel avanzado)

Esta es la parte más potente que estamos usando. Un Agente utiliza el LLM como un motor de razonamiento para decidir qué acción tomar. En lugar de seguir una lista fija de pasos, el agente mira el objetivo, elige una herramienta, observa el resultado y decide qué sigue.

Como trabaja la libreria LangChain en mi_agente.py?

1. El Concepto de "Encadenamiento" (Chains)

La razón por la que se llama LangChain es porque permite unir eslabones. En una aplicación normal, tú envías un texto y recibes un texto. En LangChain, puedes crear flujos:

• Eslabón 1: Tomar el pedido del usuario.
• Eslabón 2: Pasarlo por un filtro de seguridad.
• Eslabón 3: Consultar una base de datos o herramienta (como tus Skills).
• Eslabón 4: Dar la respuesta final.

2. Memoria de Corto Plazo (agent_scratchpad)

En tu código de mi_agente.py, verás una variable llamada {agent_scratchpad} dentro del template. Esto es vital. Los modelos de IA por sí mismos no tienen memoria de lo que acaban de hacer hace un segundo. LangChain usa este "bloc de notas" (scratchpad) para re-enviar al modelo todo lo que ha pensado y observado en los pasos anteriores. Sin esto, el agente olvidaría que ya buscó el comando cuando intentara guardarlo en el archivo.

3. Abstracción (Multimodelo)

Una ventaja enorme para tu proyecto DevOpsTechIA es que LangChain es agnóstico al modelo. Hoy usamos ChatGoogleGenerativeAI para Gemini, pero si mañana quieres probar con Claude o un modelo local en Ollama, solo cambias una línea de código. El resto de tu lógica (tus herramientas y tu agente) sigue funcionando igual.

Resumiendo

Para que esto funcione en tu máquina (por ejemplo, en VS Code o Antigravity), usaremos Python con un venv, la librería LangChain y el modelo Gemini de Google

Preparación del terreno

Crea una carpeta para el proyecto y un entorno virtual para python

python -m venv .venv
source .venv/bin/activate  # En Linux/macOS

Descarga el repositorio de github

git clone https://github.com/your-username/your-repo.git

y luego instala las dependencias via requirements.txt

pip install -r requirements.txt

Crea tu archivo .env y actualizalo con tu GOOGLE_API_KEY creada en IA Studio de Google (link aquí)

Utiliza la capa free (no es necesario ingresar los datos de tu tarjeta de crédito)

cp .env.example .env

🚀 Consigue el Código Completo

El codigo completo del proyecto esta disponible en un repositorio de github, solo te voy a pedir una pequeña ayuda para hacer crecer mis redes, que me comentes el post de "X" (twitter) y te envio el link del repositorio.

Ejecución del agente

Para ver los modelos disponibles ejecuta el script models.py

python models.py

Para ejecutar el agente que te buscara informacion sobre instalacion de terraform (En este ejemplo, puedes probar otros)

python mi_agente.py

asi se veria una salida del agente:

y el documento que genera:

Como trabaja el agente?

Al tener el modo verbose=True, verás algo fascinante en tu terminal. El proceso se llama ReAct (Reason + Act):

1. Pensamiento (Thought): El agente dirá: "El usuario quiere instalar Terraform. Tengo una herramienta llamada buscar_comando_devops. Voy a usarla."

2. Acción (Action): Ejecuta la función de Python que lanza una búsqueda en internet a través de DuckDuckGo (DDGS).

3. Observación (Observation): Recibe información actualizada desde la web con los comandos oficiales y documentación reciente.

4. Respuesta Final: El agente filtra los resultados de búsqueda, extrae los comandos correctos para tu sistema y genera la respuesta o el archivo documental.

¿Por qué esto es mejor que un simple prompt?

Si le pides a Gemini "a secas" el comando, podría darte una versión vieja o inventarse una bandera de instalación basada en datos de entrenamiento pasados. Con el Skill de búsqueda dinámica, obligas al modelo a consultar fuentes oficiales en tiempo real, asegurando que la información sea actualizada y veraz, mientras la IA se encarga de procesar, limpiar y formatear esa información. Además en el agente podrás agregar la complejidad que necesites, extención de la información, y otros skills como por ejemplo uno para que te envie el doc a telegram o que te ejecute comandos en un server para remediar un problema.

Anatomía de mi_agente.py: ¿Cómo funciona por dentro?

El corazón de este proyecto es un script de Python que integra LangChain y Google Gemini. Así es como lo construimos pieza a pieza:

A. La Configuración y los Skills

El script comienza cargando variables de entorno desde un archivo .env para proteger las credenciales. Luego, definimos dos herramientas críticas decoradas con @tool:

1. buscar_comando_devops: En lugar de usar una lista estática, esta herramienta utiliza la librería ddgs para realizar una búsqueda en tiempo real. Esto garantiza que si una tecnología cambia su método de instalación hoy mismo, el agente lo encontrará sin necesidad de actualizar el código.

2. guardar_en_markdown: Esta función es el "brazo ejecutor" que escribe archivos .md en el disco. Implementamos una lógica de separación por |||, conversión de saltos de línea y limpieza de de "eco" para asegurar que el contenido sea puro Markdown técnico.

B. El Cerebro y el Ciclo ReAct

Para el motor, seleccionamos Gemini 2.0 Flash, configurado con una temperatura de 0 para garantizar respuestas precisas y deterministas.

El funcionamiento se basa en el patrón ReAct (Reasoning + Acting), definido en un PromptTemplate. El flujo es el siguiente:

1. Thought (Pensamiento): El agente analiza la pregunta del usuario.
2. Action (Acción): Decide qué herramienta llamar (ej. buscar el comando).
3. Observation (Observación): Lee el resultado de la herramienta.
4. Final Answer: Elabora la respuesta definitiva o ejecuta la siguiente acción (ej. guardar el archivo).

C. El Ejecutor: El "Motor" de Vuelo

Finalmente, utilizamos el AgentExecutor. Este componente es vital porque gestiona los errores de "parsing" (cuando la IA no sigue el formato exacto) y permite ver en tiempo real el proceso de pensamiento mediante el modo verbose=True.

Acceso y Escalabilidad: De AI Studio a Vertex AI

Para empezar a experimentar como lo hicimos en dark7, no necesitas una infraestructura compleja desde el día uno. Aquí es donde entra el ecosistema de Google:

Cómo obtener "Tokens Gratis" en Google AI Studio

Si quieres replicar el script mi_agente.py, el camino más rápido es Google AI Studio:

1. Consigue tu API Key: Entra en aistudio.google.com y genera una "API Key". Es gratuita y te permite usar modelos como gemini-2.0-flash o versiones "Lite" de forma inmediata.
2. Configuración local: Guarda esa llave en tu archivo .env como GOOGLE_API_KEY=tu_llave.
3. Límites de la Free Tier: Como vimos durante nuestras pruebas, la versión gratuita tiene un límite (a veces de solo 20 peticiones por minuto o día según el modelo). Es ideal para prototipar el "cerebro" de tu agente, pero tiene un techo claro.

El Salto a Vertex AI (La opción Pro)

Cuando tu agente de DevOpsTechIA necesita salir de la fase de pruebas o cuando agotas la cuota gratuita, la solución no es esperar a que se resetee el contador, sino saltar a Vertex AI en Google Cloud:

• Uso de Créditos: Si tienes el crédito inicial de $300 de GCP, Vertex AI lo consume directamente, eliminando los bloqueos por cuota de la versión "Free".

• Enterprise Grade: Mientras AI Studio es para desarrolladores individuales, Vertex AI es para entornos de producción. Ofrece mayor seguridad, gestión de cuotas por región y herramientas de monitoreo (MLOps) que un perfil DevOps valorará mucho más.

• Cambio Transparente: En tu código Python, solo cambias la librería de langchain_google_genai a langchain_google_vertexai. La lógica de tus Skills y tu Agente se mantiene intacta.

Modelos: ¿Qué motores tenemos bajo el capó?

En 2026, la disponibilidad de modelos cambia drásticamente. Intentar usar versiones obsoletas (como la 1.5) genera errores 404. Para resolver esto, implementamos un script de observabilidad llamado models.py

La importancia de la Observabilidad en IA

Gracias a este script, descubrimos que contábamos con una amplia gama de opciones, desde modelos Flash-Lite (ideales para ahorrar cuota en pruebas) hasta versiones Preview de la serie 3.

Los "Lite": Tu salvación para el desarrollo

En la lista aparecen modelos como models/gemini-2.0-flash-lite y models/gemini-3.1-flash-lite-preview.

• Por qué usarlos: Los modelos Lite están diseñados específicamente para tareas de alta frecuencia. Tienen límites de peticiones por minuto (RPM) mucho más generosos que las versiones estándar o Pro.
• Rendimiento: Para las tareas de tu agente (buscar un comando en un diccionario o escribir un archivo), un modelo Lite es más que suficiente. Es rápido y consume una fracción de tu cuota.

Comparativa de Modelos Recomendados

DESAFÍOS Y LECCIONES: Resolviendo el "Mundo Real"

La teoría dice que el agente es perfecto, pero en la práctica enfrentamos desafíos reales que nos obligaron a refinar el código y aprender sobre la marcha:

• Entropía de Software: "Incluso siguiendo la documentación, el mundo de la IA cambia tan rápido que un parámetro que ayer era 'mejor práctica' (como generate), hoy genera un ValueError. En DevOps, esto se llama 'Library Drift'. Aprendimos que, a veces, la simplicidad de un frenado forzado (force) es preferible a una lógica compleja que la librería ya no soporta."

• El "Freno de Mano" puesto en 0: A veces el error más difícil de encontrar es un simple '0' en la configuración. El parámetro max_iterations es el seguro de vida de tu cuota de API, pero si lo pones en cero, tu agente quedará en un coma inducido, correra pero sin llamar al modelo. En DevOps, siempre verifica los límites de ejecución de tus orquestadores."

• Manejador de Silencio: "En la versión final de nuestro agente, implementamos un 'Manejador de Silencio'. Cuando la infraestructura de IA falla (Error 429), el usuario no ve un error de sistema; ve un aviso de mantenimiento. Es la diferencia entre un script que se rompe y una herramienta que informa.”

Primera ejecución:

Quota exceeded for metric: generativelanguage.googleapis.com/generate_content_free_tier_requests, limit: 0,
model: gemini-2.0-flash-lite
Please retry in 32.728463188s. [links {`
`description: "Learn more about Gemini API quotas"`
`url: "https://ai.google.dev/gemini-api/docs/rate-limits"`
}`
`, violations {`
`quota_metric: "generativelanguage.googleapis.com/generate_content_free_tier_input_token_count"`
`quota_id: "GenerateContentInputTokensPerModelPerMinute-FreeTier"`
`quota_dimensions {`
`key: "model"`
`value: "gemini-2.0-flash-lite"`
`}`
`quota_dimensions {`
`key: "location"`
`value: "global"`
`}`
`}`
`violations {`
`quota_metric: "generativelanguage.googleapis.com/generate_content_free_tier_requests"`
`quota_id: "GenerateRequestsPerMinutePerProjectPerModel-FreeTier"`
`quota_dimensions {`
`key: "model"`
`value: "gemini-2.0-flash-lite"`
`}`
`quota_dimensions {`
`key: "location"`
`value: "global"`
`}`
`}`
`violations {`
`quota_metric: "generativelanguage.googleapis.com/generate_content_free_tier_requests"`
`quota_id: "GenerateRequestsPerDayPerProjectPerModel-FreeTier"`
`quota_dimensions {`
`key: "model"`
`value: "gemini-2.0-flash-lite"`
`quota_dimensions {`
`key: "location"`
`value: "global"`
`}`
`, retry_delay {`
`seconds: 32`
`}`
`].`

Después de refactorizar el código

[!] Error 429: Cuota agotada.
- -----------------------------------------------------------
AVISO DE CAPA GRATUITA: Cuota de API excedida.
Por favor, espera el tiempo necesario o vincula tu crédito de GCP.
- -----------------------------------------------------------

CONCLUSIONES: El Futuro del Flujo de Trabajo Agéntico

La diferencia entre un usuario de IA y un ingeniero de IA en 2026 es la capacidad de construir flujos de trabajo cerrados. No se trata solo de esperar que la IA sea perfecta, sino de diseñar un sistema (el Agente) que sea capaz de manejar herramientas (Skills) y procesar instrucciones (Prompts) de forma coherente y autónoma.

🎯 El Hito de tu Primer Agente

Crear tu primer agente es un cambio de paradigma. Pasas de ser un consumidor de contenido generado a ser un arquitecto de soluciones. Al construir mi_agente.py, no solo escribimos código; le dimos a una inteligencia digital la capacidad de percibir su entorno (mediante búsquedas web) y de actuar sobre él (escribiendo archivos). Este primer paso es la base para automatizaciones mucho más complejas, como agentes que despliegan infraestructura completa o auditan la seguridad de tus servidores sin intervención humana.

🔗 Sinergia entre Modelos y Librerías

Este proyecto nos demuestra que el verdadero poder de la IA moderna no reside únicamente en el modelo (Gemini), sino en cómo lo integramos con librerías potentes como LangChain y DDGS. - Modelos como Motores: Aprendimos que el LLM es un "motor de razonamiento" que puede ser intercambiado. Lo que hoy es Gemini, mañana puede ser un modelo local de código abierto, y tu lógica de DevOps seguirá intacta. - Librerías como Sentidos: Sin langchain, la gestión del ciclo ReAct sería una pesadilla de programación manual. Sin ddgs, nuestra IA viviría en el pasado, limitada por sus datos de entrenamiento. Las librerías son las que permiten que el modelo "toque" la realidad.

💡 Un Nuevo Enfoque para el DevOps

Dominar la IA requiere saber mitigar la entropía y los errores de "basura" en los datos. Empezar con los tokens gratuitos de AI Studio te permite aprender a limpiar tus archivos Markdown o gestionar errores de cuota. Pero saber que tienes el respaldo de Vertex AI y tus créditos de Cloud es lo que te permite escalar esa automatización a un nivel profesional.

⚖️ ¿Web o Agente? Cuándo usar cada uno

Tareas Recurrentes: Quieres un proceso que se ejecute solo (por ejemplo, un script que busque vulnerabilidades cada noche y genere un reporte).

Control de Privacidad: Necesitas filtrar o procesar datos sensibles localmente antes de decidir qué "cerebro" de IA consultará la información.

📦 Accedé al Repositorio Completo

Si quieres profundizar y tener el entorno listo para correr en tu máquina, he preparado un repositorio en GitHub que incluye:

• El script mi_agente.py final con todas las correcciones
• EL script models.py para que veas tus modelos disponibles
• Los archivos de dependencias como requirements.txt para instalar lo necesario
• La configuración de seguridad para proteger tus llaves.

¿Cómo conseguirlo?

¡Nos vemos en la terminal! 🚀

Este artículo es parte del material de aprendizaje sobre agentes de IA aplicados a infraestructura.