Mi viaje en los agentes de IA locales primero

¡Hola, agente en formación! Emma aquí, de vuelta de otra inmersión nocturna en el fascinante mundo de los agentes de IA. Sabes cómo es esto: un minuto estás desplazándote por algún repositorio de GitHub desconocido, y al siguiente son las 3 AM y acabas de descubrir cómo hacer que tu pequeño amigo digital te pida una pizza (hipotéticamente, por supuesto… en su mayoría).

Hoy quiero hablar de algo que ha estado surgiendo en todas partes últimamente, y con buena razón: agentes de IA locales primero. Olvida a los grandes proveedores de la nube, los costos de la API que se te escapan y la sensación molesta de que tus datos están flotando en algún éter digital. Hablamos de llevar la acción del agente directamente a tu máquina, dándote más control, más privacidad y, francamente, un bucle de retroalimentación mucho más rápido.

Si eres como yo, comenzaste este viaje con una buena dosis de escepticismo. “¿Agentes? ¿En mi viejo portátil? Pffft.” Pero créeme, la tecnología ha avanzado increíblemente rápido. Y como alguien que siempre aboga por los principiantes, este enfoque local primero es, en mi opinión, una de las mejores formas de *aprender* realmente cómo funcionan estas cosas sin arruinarse o perderse en configuraciones complejas en la nube.

¿Por qué optar por Local-First con tu Agente de IA? Mi momento de “¡Eureka!”

Entonces, ¿por qué estoy tan entusiasmada con esto? Bueno, imagina esto: hace unos meses, estaba tratando de construir un agente simple para ayudarme a resumir largos documentos de investigación. Mi pensamiento inicial fue usar uno de los grandes LLMs públicos, conectar a través de una API, y a rodar. Pasé una buena parte de una tarde lidiando con tokens de autenticación, límites de tasa, y luego el inevitable shock de la factura al darme cuenta de cuántos tokens estaba quemando solo en pruebas.

Fue frustrante, honestamente. Cada vez que quería ajustar un prompt o probar una nueva cadena de pensamiento, estaba esperando la latencia de la red y viendo cómo mi presupuesto hipotético se reducía. Sentía que estaba aprendiendo más a *usar* una API que sobre el comportamiento agente.

Entonces, un amigo mencionó ejecutar un LLM local. Me reí. “¡Mi MacBook Air apenas puede ejecutar Photoshop, y mucho menos un modelo de lenguaje grande!” Pero insistieron, señalándome hacia frameworks como Ollama y modelos más pequeños y optimizados. Escépticamente, decidí intentarlo.

La primera vez que vi a mi agente responder *instantáneamente* a un prompt, sin una llamada de red, sin un cargador girando, fue un absoluto momento de “¡eureka!”. Sentía que realmente había tomado posesión del proceso. Podía iterar más rápido, experimentar más libremente y realmente comenzar a entender el funcionamiento interno sin distracciones externas. Fue empoderador, y esa es exactamente la sensación que quiero que tengas.

¿Qué queremos decir exactamente con “Local-First”?

Cuando digo “agente de IA local primero”, me refiero a un agente de IA cuya inteligencia central (el Modelo de Lenguaje Grande, o LLM) se ejecuta directamente en tu computadora personal, en lugar de depender de un servidor remoto o servicio en la nube. El propio agente, que orquesta el LLM, herramientas y memoria, también vive en tu máquina.

Este enfoque no se trata de reemplazar soluciones poderosas basadas en la nube para aplicaciones masivas y de nivel de producción. Se trata de:

• Privacidad: Tus datos nunca salen de tu máquina. Punto.
• Costo: Sin tarifas de API. El único costo es tu factura de electricidad y tal vez una descarga inicial.
• Velocidad: Las respuestas son a menudo mucho más rápidas ya que no hay latencia de red.
• Control: Tú decides qué modelos ejecutar, cómo configurarlos y cuándo actualizar.
• Aprendizaje: Es un sandbox incomparable para entender cómo funcionan realmente los LLMs y los agentes juntos.

Piénsalo como la diferencia entre transmitir una película y tenerla descargada en tu disco duro. Ambas te dan la película, pero una te da más control directo y menos dependencia de factores externos.

Empezando: Tu Primer Sandbox de Agente Local

¡Muy bien, suficiente de teoría! Manos a la obra. Para esto, vamos a necesitar un par de cosas:

1. Ollama: Esta es una herramienta fantástica que hace que ejecutar LLMs de código abierto localmente sea increíblemente fácil. Maneja todas las cosas complejas como la cuantización de modelos y la aceleración de GPU por ti.
2. Un entorno de Python: Porque, bueno, Python es la lengua franca de la IA.
3. Un framework básico de agente: Usaremos algo sencillo para conectar nuestro LLM a algunas herramientas básicas.

Paso 1: Instala Ollama y Descarga un Modelo

Primero, dirígete a ollama.com y descarga el instalador para tu sistema operativo. Está disponible para macOS, Linux y Windows.

Una vez instalado, abre tu terminal (o símbolo del sistema) y vamos a descargar un modelo. Para principiantes, recomiendo encarecidamente ‘llama2’ o ‘mistral’. Son buenos modelos de propósito general, relativamente pequeños y funcionan bien en la mayoría de las máquinas modernas.

ollama run llama2

Este comando descargará el modelo `llama2` (puede tardar unos minutos dependiendo de tu conexión a internet) y luego iniciará una sesión de chat interactiva con él. ¡Intenta hacerle una pregunta! Si responde, ¡felicitaciones, tienes un LLM ejecutándose localmente!

Escribe `/bye` para salir de la sesión de chat.

Paso 2: Configura tu Entorno de Python

Si aún no tienes Python instalado, ahora es un buen momento. Normalmente recomiendo usar `venv` para entornos de proyectos aislados.

mkdir local_agent_project
cd local_agent_project
python3 -m venv venv
source venv/bin/activate # En Windows, usa `venv\Scripts\activate`
pip install requests beautifulsoup4 # Necesitaremos esto para una herramienta simple de scraping web

Paso 3: Construyendo un Agente Súper Simple

¡Ahora viene la parte divertida! Vamos a crear un agente básico de “asistente de investigación” que puede usar una “herramienta” para navegar por una página web y resumir su contenido. Este agente decidirá *cuándo* usar la herramienta según tu prompt.

Crea un archivo llamado `simple_agent.py` en tu directorio `local_agent_project`.

import requests
from bs4 import BeautifulSoup
import json

# --- Definiciones de Herramientas ---
def browse_webpage(url: str) -> str:
 """
 Navega a una URL dada y devuelve el contenido de texto principal de la página.
 Útil para obtener información de sitios web.
 """
 try:
 headers = {'User-Agent': 'Mozilla/5.0'} # Fingir ser un navegador real
 response = requests.get(url, headers=headers, timeout=10)
 response.raise_for_status() # Lanzar una excepción para códigos de estado incorrectos
 soup = BeautifulSoup(response.text, 'html.parser')
 
 # Un intento muy básico de obtener el contenido principal, ajustar según sea necesario
 paragraphs = soup.find_all('p')
 text_content = ' '.join([p.get_text() for p in paragraphs])
 
 # Limitar el contenido para evitar abrumar al LLM
 return text_content[:2000] + "..." if len(text_content) > 2000 else text_content
 except requests.exceptions.RequestException as e:
 return f"Error navegando la URL {url}: {e}"
 except Exception as e:
 return f"Se produjo un error inesperado: {e}"

# --- Núcleo del Agente ---
class LocalAgent:
 def __init__(self, model_name="llama2"):
 self.model_name = model_name
 self.ollama_api_url = "http://localhost:11434/api/generate"
 self.available_tools = {
 "browse_webpage": browse_webpage
 }
 self.tool_schemas = {
 "browse_webpage": {
 "name": "browse_webpage",
 "description": "Navega a una URL dada y devuelve el contenido de texto principal de la página. Útil para obtener información de sitios web.",
 "parameters": {
 "type": "object",
 "properties": {
 "url": {"type": "string", "description": "La URL a navegar."}
 },
 "required": ["url"]
 }
 }
 }
 self.history = [] # Para llevar el registro de la conversación

 def _call_ollama(self, prompt: str, system_message: str = "", temperature: float = 0.7):
 # Esta es una llamada simplificada para demostración
 # Los agentes del mundo real podrían usar un prompting más sofisticado o bibliotecas
 headers = {'Content-Type': 'application/json'}
 data = {
 "model": self.model_name,
 "prompt": prompt,
 "system": system_message,
 "stream": False,
 "temperature": temperature,
 "options": {
 "num_predict": 500 # Limitar la longitud de la salida
 }
 }
 try:
 response = requests.post(self.ollama_api_url, headers=headers, json=data)
 response.raise_for_status()
 return response.json()['response']
 except requests.exceptions.RequestException as e:
 print(f"Error llamando a Ollama: {e}")
 return "Ocurrió un error con el LLM."

 def run(self, user_query: str):
 self.history.append({"role": "user", "content": user_query})

 # Paso 1: El LLM decide si se necesita una herramienta
 # Usaremos un prompt específico para fomentar el uso de herramientas
 tool_prompt = f"""
Eres un asistente de AI útil. Tienes acceso a las siguientes herramientas:

{json.dumps(list(self.tool_schemas.values()), indent=2)}

Basado en la solicitud del usuario, decide si necesitas usar una herramienta.
Si necesitas usar una herramienta, responde SOLO con un objeto JSON en el formato:
```json
{{
 "tool_name": "nombre_de_la_herramienta",
 "tool_args": {{
 "arg1": "valor1",
 "arg2": "valor2"
 }}
}}
```
Si NO necesitas una herramienta, o si puedes responder directamente, responde directamente a la solicitud del usuario.
Sé conciso y útil.

Solicitud del usuario: {user_query}
"""
 print(f"\n[Agente Pensando - Decisión de Herramienta para: {user_query}]")
 tool_decision_raw = self._call_ollama(tool_prompt, temperature=0.0) # Baja temperatura para salida estructurada

 try:
 tool_call = json.loads(tool_decision_raw)
 tool_name = tool_call.get("tool_name")
 tool_args = tool_call.get("tool_args", {})

 if tool_name and tool_name in self.available_tools:
 print(f"[Agente Decidió Usar Herramienta: {tool_name} con args: {tool_args}]")
 tool_output = self.available_tools[tool_name](**tool_args)
 self.history.append({"role": "tool_output", "content": tool_output})
 print(f"[Salida de Herramienta Recibida: {tool_output[:100]}...]")

 # Paso 2: El LLM resume o responde basado en la salida de la herramienta
 summary_prompt = f"""
Anteriormente recibiste la siguiente solicitud del usuario: "{user_query}"
Utilizaste la herramienta '{tool_name}' con argumentos {tool_args}.
La herramienta devolvió la siguiente información:

{tool_output}

Basado en esta información y la solicitud original del usuario, proporciona una respuesta concisa.
"""
 final_response = self._call_ollama(summary_prompt)
 self.history.append({"role": "assistant", "content": final_response})
 return final_response
 else:
 # Si intentó llamar a una herramienta inexistente o no devolvió JSON válido
 print(f"[El Agente No Usó Herramienta (o llamada a herramienta inválida): {tool_decision_raw}]")
 # Recaída: Solo pedir al LLM que responda directamente
 direct_answer = self._call_ollama(f"Responde la siguiente pregunta: {user_query}")
 self.history.append({"role": "assistant", "content": direct_answer})
 return direct_answer
 except json.JSONDecodeError:
 print(f"[El Agente No Devolvió JSON para la Llamada de Herramienta. Dirigiendo al LLM para responder directamente.]")
 # Si el LLM no devolvió JSON válido para una llamada de herramienta, simplemente déjalo responder directamente
 direct_answer = self._call_ollama(f"Responde la siguiente pregunta: {user_query}")
 self.history.append({"role": "assistant", "content": direct_answer})
 return direct_answer
 except Exception as e:
 print(f"[Ocurrió un error inesperado durante la ejecución de la herramienta: {e}. Dirigiendo al LLM para responder directamente.]")
 direct_answer = self._call_ollama(f"Responde la siguiente pregunta: {user_query}")
 self.history.append({"role": "assistant", "content": direct_answer})
 return direct_answer


# --- Ejecuta el Agente ---
if __name__ == "__main__":
 agent = LocalAgent(model_name="llama2") # Asegúrate de que 'llama2' esté descargado con Ollama
 
 print("¡Bienvenido a tu agente de investigación local! Escribe 'quit' para salir.")
 while True:
 user_input = input("\nTu consulta: ")
 if user_input.lower() == 'quit':
 break
 
 response = agent.run(user_input)
 print(f"\nAgente: {response}")

Cómo Funciona el Agente (Brevemente):

• Tiene una función `browse_webpage` que actúa como su “herramienta.”
• Cuando le das una consulta, primero pregunta al modelo `llama2`: “¿Necesito usar una herramienta para responder a esto?” Le da al LLM la descripción de la herramienta y espera un formato JSON específico si decide usar una.
• Si el LLM decide usar `browse_webpage`, extrae la URL, llama a la función `browse_webpage` y obtiene el contenido.
• Luego, alimenta ese contenido *de vuelta* al LLM junto con tu consulta original y le pide que responda.
• Si el LLM no decide usar una herramienta, o si su llamada a la herramienta está malformada, simplemente intenta responder tu consulta directamente.

Paso 4: ¡Ejecuta Tu Agente!

Asegúrate de que tu instancia de Ollama esté corriendo en segundo plano (puedes dejar `ollama run llama2` abierto en una terminal separada, o simplemente asegúrate de que la aplicación Ollama esté funcionando). Luego, en tu directorio `local_agent_project`, ejecuta:

python simple_agent.py

Prueba estas consultas:

• `¿Cuál es la capital de Francia?` (Debería responder directamente sin una herramienta)
• `Resume las características clave del último iPhone del sitio web de Apple.` (Podría intentar navegar apple.com)
• `¿Cuáles son los beneficios de aprender Python de wikipedia.org/wiki/Python_(programming_language)?` (¡Definitivamente debería usar la herramienta!)

Verás mensajes como `[Agente Pensando – Decisión de Herramienta…]` y `[Agente Decidió Usar Herramienta…]` en tu terminal, que son el monólogo interno del agente, mostrándote su proceso de toma de decisiones. ¡Esto es invaluable para entender cómo funciona!

Una nota personal aquí: No te desanimes si el LLM no siempre toma la decisión “perfecta”. Este es un agente muy básico. El arte de construir agentes a menudo implica refinar los prompts, agregar mecanismos de llamada a herramientas más sofisticados y darle al LLM más contexto y ejemplos. Pero para un primer paso, ¡esto es enorme!

Limitaciones y Lo Que Viene

Por supuesto, este agente simple tiene sus limitaciones:

• Herramientas Limitadas: Solo tenemos una herramienta. Los agentes reales tienen muchas.
• Toma de Decisiones Simple: La decisión del LLM sobre el uso de herramientas se basa en un solo prompt. Los agentes más avanzados utilizan prompts “planificación” estructurados o bibliotecas como LangChain o CrewAI.
• Sin Memoria (más allá del contexto inmediato): Nuestro agente no recuerda turnos anteriores en una conversación.
• Alucinaciones del LLM: Los LLM locales aún pueden “inventar cosas,” al igual que sus contrapartes en la nube.

Pero aquí está la parte genial: como es local primero, ¡puedes experimentar con arreglar estos problemas! Intenta agregar otra herramienta (por ejemplo, una calculadora). Intenta mejorar el prompt del sistema para el uso de herramientas. Intenta integrar un marco de agente más solido. El mundo es tu ostra, y todo está funcionando en tu máquina.

Esta configuración amigable para principiantes te permite iterar rápidamente sin preocuparte por los costos de API o implementaciones complejas. Es el entorno perfecto para fallar rápido, aprender más rápido y realmente entender la mecánica de los agentes de AI.

Conclusiones Acciónables para Tu Viaje con el Agente

1. Comienza Pequeño, Mantente Local: Resiste la tentación de saltar directamente a implementaciones en la nube complejas. Haz que un LLM local funcione con Ollama y construye agentes simples en tu máquina.
2. Experimenta con los Prompts: El prompt es el cerebro del agente. Juega con diferentes instrucciones, ejemplos y mensajes del sistema. Ve cómo los pequeños cambios afectan el comportamiento.
3. Construye Más Herramientas: Piensa en tareas que realizas a menudo. ¿Puedes escribir una pequeña función en Python para ello? Conviértela en una herramienta para tu agente.
4. Lee Código Abierto: Observa cómo los proyectos en GitHub están construyendo agentes. No solo copies y pegues, intenta entender la lógica.
5. Únete a Comunidades: Encuentra foros, servidores de Discord o encuentros locales enfocados en agentes de AI y LLMs. Aprender de otros es increíblemente valioso.

Mi viaje en el mundo de los agentes de IA realmente despegó cuando dejé de tratarlos como cajas negras y comencé a ensuciarme las manos con configuraciones locales. Esto eliminó la complejidad intimidante y me permitió enfocarme en la lógica básica. Realmente creo que esa es la forma más rápida y efectiva para que cualquier principiante pase de “¿Qué es un agente de IA?” a “¡Mira lo que mi agente puede hacer!”

¡Feliz construcción, y nos vemos la próxima vez!

🕒 Last updated: March 26, 2026  ·  Originally published: March 25, 2026