Tutorial de Comparación de Agent SDK: Construyendo Aplicaciones Inteligentes con Ejemplos Prácticos

Introducción a los SDK de Agentes

El ámbito de la inteligencia artificial está evolucionando rápidamente, con un creciente énfasis en agentes inteligentes capaces de realizar tareas complejas, interactuar con los usuarios y adaptarse a entornos dinámicos. Construir dichos agentes desde cero puede ser una tarea desalentadora, que requiere experiencia en procesamiento de lenguaje natural, aprendizaje automático, representación del conocimiento y más. Aquí es donde entran los SDK de Agentes (Kits de Desarrollo de Software). Los SDK de Agentes proporcionan a los desarrolladores componentes, marcos y herramientas preconstruidos para acelerar el desarrollo de agentes inteligentes, abstraiendo gran parte de la complejidad subyacente.

Un SDK de Agente típicamente ofrece funcionalidades para definir comportamientos de agentes, gestionar flujos conversacionales, integrarse con herramientas y APIs externas, manejar memoria y contexto, y a menudo incluye características para despliegue y monitoreo. Elegir el SDK de Agente adecuado es crucial para el éxito de tu proyecto, ya que diferentes SDKs se adaptan a varios casos de uso, lenguajes de programación y niveles de abstracción. Este tutorial tiene como objetivo proporcionar una comparación práctica de varios SDK de Agentes populares, ilustrando sus fortalezas y debilidades a través de ejemplos concretos.

Características Clave a Considerar en un SDK de Agente

• Soporte de Lenguajes: ¿Soporta tu lenguaje de programación preferido (Python, JavaScript, Java, etc.)?
• Facilidad de Uso y Curva de Aprendizaje: ¿Qué tan rápidamente puede un nuevo desarrollador volverse productivo con el SDK?
• Capacidades de Integración: ¿Puede integrarse fácilmente con otros servicios, APIs, bases de datos y sistemas existentes?
• Gestión de Estado y Memoria: ¿Qué tan bien maneja el contexto conversacional y la memoria a largo plazo del agente?
• Orquestación y Flujo de Trabajo: ¿Proporciona herramientas para definir comportamientos complejos de los agentes, toma de decisiones y procesos de múltiples pasos?
• Escalabilidad y Rendimiento: ¿Puede manejar un alto volumen de interacciones y cálculos complejos?
• Opciones de Despliegue: ¿Cuáles son los entornos de despliegue soportados (nube, local, sin servidor)?
• Comunidad y Documentación: ¿Hay una comunidad activa y documentación completa para asistir durante el desarrollo?
• Extensibilidad: ¿Qué tan fácil es extender las funcionalidades del SDK con componentes personalizados?

Comparando SDK de Agentes: LangChain vs. LlamaIndex vs. Microsoft Semantic Kernel

Para este tutorial, nos enfocaremos en tres SDK de Agentes prominentes y ampliamente utilizados: LangChain, LlamaIndex y Microsoft Semantic Kernel. Cada uno de estos ofrece un enfoque único para construir agentes inteligentes, particularmente aquellos que utilizan modelos de lenguaje grande (LLMs).

1. LangChain: El Orquestador para Aplicaciones Potenciadas por LLM

LangChain ha surgido rápidamente como un marco dominante para desarrollar aplicaciones potenciadas por modelos de lenguaje grandes. Su filosofía principal gira en torno a ‘encadenar’ diferentes componentes para crear flujos de trabajo complejos. Proporciona un conjunto completo de abstracciones para interactuar con LLMs, gestionar avisos, manejar memoria conversacional, integrarse con herramientas externas (Agentes) y recuperar información de diversas fuentes de datos (Recuperación).

Características Clave de LangChain:

• Cadenas: Definir secuencias de llamadas, por ejemplo, plantillas de aviso + LLM + analizador de salida.
• Agentes: Permiten a los LLMs elegir una secuencia de acciones a seguir, a menudo utilizando herramientas.
• Memoria: Almacenar y recuperar información sobre interacciones pasadas.
• Cargadores: Cargar datos desde varias fuentes (PDFs, sitios web, bases de datos).
• Vectorstores: Almacenar y consultar incrustaciones para búsqueda semántica.
• Herramientas: Funcionalidades externas que un agente puede utilizar (por ejemplo, motores de búsqueda, calculadoras, APIs personalizadas).

Ejemplo Práctico de LangChain: Un Agente Conversacional Simple con Uso de Herramientas

Construyamos un agente de LangChain que pueda responder preguntas generales y también usar una herramienta calculadora si se detecta una operación matemática.

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_core.tools import Tool
from langchain.chains import LLMMathChain

# 1. Inicializar el LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")

# 2. Definir Herramientas
# Herramienta calculadora
llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True)
calculator = Tool(
 name="Calculator",
 func=llm_math_chain.run,
 description="Útil para cuando necesitas responder preguntas sobre matemáticas."
)

tools = [calculator]

# 3. Obtener el aviso del LangChain Hub (estilo ReAct)
# El aviso ReAct guía al LLM para pensar, observar y actuar.
prompt = hub.pull("hwchase17/react")

# 4. Crear el agente ReAct
agent = create_react_agent(llm, tools, prompt)

# 5. Crear el Ejecutador de Agentes
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# 6. Ejecutar el agente
print(agent_executor.invoke({"input": "¿Cuál es la capital de Francia?"}))
print(agent_executor.invoke({"input": "¿Cuál es 1234 * 5678?"}))

Explicación:

• Inicializamos un modelo de Chat de OpenAI.
• Definimos una herramienta Calculator utilizando LLMMathChain de LangChain.
• Obtenemos un aviso estándar ReAct del LangChain Hub. ReAct (Razonamiento y Actuación) es un paradigma que permite a los LLMs realizar razonamientos dinámicos y planificación de acciones.
• create_react_agent combina el LLM, las herramientas y el aviso para crear un agente.
• AgentExecutor es responsable de ejecutar el agente, gestionar su proceso de pensamiento y ejecutar herramientas.
• Cuando se pregunta sobre la capital de Francia, el LLM responde directamente. Cuando se le hace una pregunta de matemáticas, reconoce la necesidad de la calculadora, llama a la herramienta y proporciona el resultado.

2. LlamaIndex: Marco de Datos para Aplicaciones LLM

Mientras que LangChain se centra en gran medida en la orquestación y encadenamiento de llamadas LLM, LlamaIndex (anteriormente GPT Index) se especializa en la ingestión de datos, indexación y recuperación para aplicaciones LLM. Su objetivo principal es facilitar la conexión de los LLMs con fuentes de datos personalizadas, habilitando poderosas aplicaciones RAG (Generación Aumentada por Recuperación). LlamaIndex sobresale en la construcción de bases de conocimientos y en hacerlas consultables por los LLMs.

Características Clave de LlamaIndex:

• Conectores de Datos: Ingesta de datos desde varias fuentes (documentos, bases de datos, APIs).
• Indexación de Datos: Estructurar y almacenar datos de manera optimizada para consultas LLM (por ejemplo, almacenes vectoriales, gráficos de conocimiento).
• Motores de Consulta: Recuperar información relevante de los índices y sintetizar respuestas utilizando LLMs.
• Agentes: Combinar motores de consulta con herramientas y LLMs para un razonamiento más complejo y de múltiples pasos sobre los datos.
• Contexto de Servicio: Gestionar LLM, modelo de incrustación y otras configuraciones de servicio.

Ejemplo Práctico de LlamaIndex: Consultando un Documento Personalizado

Creemos una aplicación simple de LlamaIndex que pueda responder preguntas basadas en un archivo de texto local.

# Primero, crear un archivo ficticio: 'policy.txt'
# Contenido:
# "La política de vacaciones de nuestra empresa otorga a los empleados 15 días de tiempo libre pagado por año. 
# Después de 5 años de servicio, los empleados reciben 5 días adicionales. 
# Los días de vacaciones no utilizados no se trasladan al año siguiente."

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding
import os

# Establecer la clave API de OpenAI (asegúrate de que esté en tus variables de entorno)
# os.environ["OPENAI_API_KEY"] = "TU_API_KEY"

# 1. Configurar LLM y Modelo de Incrustación (opcional, pero buena práctica)
Settings.llm = OpenAI(model="gpt-4o", temperature=0)
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")

# 2. Cargar documentos desde un directorio
documents = SimpleDirectoryReader("data").load_data() # Suponiendo que 'policy.txt' está en un directorio 'data'

# 3. Crear un índice a partir de los documentos (VectorStoreIndex es común)
index = VectorStoreIndex.from_documents(documents)

# 4. Crear un motor de consulta
query_engine = index.as_query_engine()

# 5. Consultar el motor
response = query_engine.query("¿Cuántos días de vacaciones reciben los empleados por año?")
print(response)

response = query_engine.query("¿Qué pasa con los días de vacaciones no utilizados?")
print(response)

Explicación:

• Primero creamos un archivo policy.txt en un directorio data.
• Configuramos el LLM y el modelo de incrustación a través de Settings.
• SimpleDirectoryReader carga el archivo de texto.
• VectorStoreIndex.from_documents procesa los documentos, los divide en fragmentos, los incrusta y los almacena en una base de datos vectorial (en memoria por defecto).
• index.as_query_engine() crea una interfaz para consultar el índice.
• Cuando se realiza una consulta, el motor de consulta recupera fragmentos de documentos relevantes basados en similitud semántica y luego utiliza el LLM para sintetizar una respuesta a partir de esos fragmentos.

3. Microsoft Semantic Kernel: El Orquestador para Aplicaciones Potenciadas por IA con Plugins

Microsoft Semantic Kernel (SK) es un SDK de código abierto que permite a los desarrolladores integrar modelos de lenguaje grandes (LLMs) y otras capacidades de IA en sus aplicaciones utilizando los lenguajes de programación existentes (C#, Python, Java). Se centra en permitir que las aplicaciones orquesten interacciones con LLMs y código tradicional, enfatizando una arquitectura de ‘plugin’. SK es particularmente fuerte para desarrolladores que ya están dentro del ecosistema de Microsoft o aquellos que buscan un marco sólido de nivel empresarial.

Características Clave de Semantic Kernel:

• Núcleo: El motor central de orquestación para AI y código tradicional.
• Habilidades/Plugins: Colecciones de funciones semánticas (prompts de LLM) y funciones nativas (código tradicional) que la AI puede invocar.
• Funciones Semánticas: Prompts que definen lo que el LLM debería hacer.
• Funciones Nativas: Métodos de código tradicional expuestos a la AI, permitiendo que interactúe con sistemas externos.
• Memoria: Almacenar y recuperar información para el contexto conversacional.
• Planificadores: Permiten que la AI planifique y ejecute una secuencia de habilidades para alcanzar un objetivo.

Ejemplo Práctico del Núcleo Semántico: Un Planificador Simple con Plugin Personalizado

Creemos una aplicación de Núcleo Semántico que pueda saludar al usuario y también realizar una operación aritmética simple utilizando una función nativa personalizada (plugin).

import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.functions import kernel_function
import asyncio

# 1. Inicializar el Núcleo
kernel = sk.Kernel()

# 2. Configurar el servicio LLM
# Asegúrate de que tu OPENAI_API_KEY esté configurado como una variable de entorno
kernel.add_service(
 OpenAIChatCompletion(
 service_id="chat_completion",
 ai_model_id="gpt-4o",
 ),
)

# 3. Definir un plugin nativo personalizado (Habilidades en SK)
class MathPlugin:
 @kernel_function(description="Suma dos números.", name="Add")
 def add(self, num1: float, num2: float) -> float:
 return num1 + num2

 @kernel_function(description="Multiplica dos números.", name="Multiply")
 def multiply(self, num1: float, num2: float) -> float:
 return num1 * num2

# 4. Importar el plugin en el núcleo
kernel.add_plugin(MathPlugin(), plugin_name="MyMathPlugin")

# 5. Definir una función semántica (para conversación general)
# Este es un prompt simple que puede ser invocado directamente o utilizado por un planificador
prompt_template = "{{$input}}"
chat_function = kernel.create_function_from_prompt(
 prompt_template=prompt_template,
 plugin_name="ChatPlugin",
 function_name="Chat"
)

async def main():
 # 6. Invocar la función de chat directamente
 result = await kernel.invoke(chat_function, sk.KernelArguments(input="Hola, ¿qué puedes hacer por mí?"))
 print(f"Respuesta del chat: {result}")

 # 7. Usar un planificador para orquestar acciones, incluyendo nuestro MathPlugin
 # Para planificación compleja, usarías un planificador dedicado como SequentialPlanner
 # Para este ejemplo simple, demostraremos una llamada directa a través del prompt con capacidades de llamada a funciones
 
 # El LLM, al ser invocado con el prompt correcto, reconocerá y usará los plugins registrados.
 # Creemos un objetivo para que el LLM lo alcance utilizando los plugins disponibles.
 
goal = "Necesito saber la suma de 10 y 20, y luego multiplicar ese resultado por 3."

 # El mecanismo de llamada a función de SK permite que el LLM elija la función correcta.
 # Usaremos un servicio de completado de chat directamente, permitiendo que use herramientas.
 history = kernel.create_chat_history()
 history.add_user_message(goal)

 response = await kernel.get_service("chat_completion").get_chat_message_content(
 history=history,
 settings=sk.OpenAIChatCompletionSettings(function_call="auto")
 )
 print(f"Respuesta del planificador: {response}")

if __name__ == "__main__":
 asyncio.run(main())

Explicación:

• Inicializamos el Núcleo y añadimos un servicio de completado de chat de OpenAI.
• Definimos una clase MathPlugin con decoradores @kernel_function, exponiendo add y multiply como funciones nativas.
• Importamos este plugin en el núcleo.
• Se crea una función semántica simple chat_function para la interacción directa con el LLM.
• En main(), primero invocamos la función de chat directamente.
• Luego, para el ejemplo de planificación, creamos un historial de chat con un objetivo. Al usar function_call="auto" en la configuración, se le permite al LLM decidir si responder directamente o llamar a una de las funciones nativas registradas (plugins) para alcanzar el objetivo. SK maneja la traducción de la llamada a función del LLM en invocaciones de métodos reales y luego alimenta el resultado de nuevo al LLM.

Elegir el SDK de Agente Adecuado

La elección del SDK de Agente depende en gran medida de las necesidades específicas de tu proyecto y de la tecnología que ya tengas:

• Elige LangChain si:
  • Necesitas orquestación extensa de LLM, comportamiento agente complejo y encadenamiento flexible de componentes.
  • Quieres integrar una amplia variedad de LLMs, herramientas y tipos de memoria.
  • Estás creando aplicaciones que implican razonamiento en múltiples pasos, selección dinámica de herramientas y agentes conversacionales.
  • Valoras una comunidad grande y activa y ejemplos extensos.
• Elige LlamaIndex si:
  • Tu enfoque principal está en conectar LLMs a tus datos personalizados (documentos, bases de datos, API) para RAG.
  • Necesitas sólidas capacidades de ingestión de datos, indexación y recuperación.
  • Estás construyendo sistemas de preguntas y respuestas para bases de conocimiento, resumidores de documentos o agentes conscientes de datos.
  • Priorizas una gestión de datos eficiente y escalable para LLMs.
• Elige Microsoft Semantic Kernel si:
  • Eres un desarrollador de C#, Python o Java que busca integrar AI sin problemas en aplicaciones existentes.
  • Quieres un marco sólido y listo para empresas de Microsoft.
  • Necesitas combinar capacidades de LLM (funciones semánticas) con código tradicional (funciones nativas/plugins) de una manera estructurada.
  • Estás creando aplicaciones que requieren que la AI interactúe con tus sistemas internos y APIs.

Conclusión

Los SDK de Agente son herramientas indispensables para construir aplicaciones AI sofisticadas. LangChain, LlamaIndex y Microsoft Semantic Kernel ofrecen características poderosas adaptadas a diferentes aspectos del desarrollo AI. LangChain se destaca en la orquestación de flujos de trabajo de LLM complejos y razonamiento agente. LlamaIndex es la opción ideal para la integración de datos y generación aumentada por recuperación. Semantic Kernel proporciona una base sólida para integrar AI en aplicaciones existentes con una arquitectura de plugins solida, especialmente para casos de uso en empresas. Al comprender sus fuerzas principales y verlas en acción a través de ejemplos prácticos, ahora estás mejor equipado para seleccionar el SDK adecuado para dar vida a tus ideas de agentes inteligentes.

🕒 Published: March 26, 2026