LinuxParty

Crea tu primer agente de IA

| Escrito por Javier Orovengua | Correo electrónico | Visto: 49
Inicio desactivadoInicio desactivadoInicio desactivadoInicio desactivadoInicio desactivado
 

El crecimiento de la inteligencia artificial (IA) agencial se ve impulsado por la complejidad de las tareas que realizan las máquinas. Los agentes de IA se están convirtiendo en una parte esencial de nuestro panorama tecnológico, ya sea para vehículos autónomos o robots conversacionales. En el corazón de la IA agencial se encuentra la arquitectura que determina cómo los agentes perciben, aprenden, deciden y actúan. Las herramientas y los marcos utilizados para construir estos agentes son múltiples, y cada uno ofrece la capacidad de abordar problemas específicos. Navegar por estas plataformas es abrumador, pero es crucial para diseñar agentes eficaces e inteligentes.

En esencia, la IA agencial se refiere a sistemas que pueden tomar decisiones y actuar por sí mismos sin necesidad de intervención humana constante. El uso más común de este tipo de IA se encuentra en agentes autónomos, que se encargan de desplazarse por espacios, resolver problemas e interactuar con humanos u otras máquinas. Para construir estos agentes, es necesario un conocimiento sólido tanto de los principios teóricos como de las herramientas de trabajo.

Los desarrolladores utilizan Frameworks (marcos) especializados que proporcionan herramientas para crear y gestionar agentes de IA de forma eficiente. Estos son algunos de los marcos de IA con agentes más importantes que se utilizan actualmente.

Microsoft AutoGen

AutoGen es un marco de programación de código abierto para crear agentes de IA y facilitar la cooperación entre ellos para resolver tareas. Está diseñado para gestionar sistemas multiagente donde diferentes agentes de IA colaboran para resolver problemas complejos. Permite que los agentes de IA trabajen de forma independiente o con intervención humana, lo que permite soluciones de IA flexibles y escalables.

Características principales:

  • Admite flujos de trabajo de múltiples agentes y colaboración en tiempo real.
  • Integra interacciones humanas para la supervisión y la toma de decisiones.
  • Proporciona gestión de memoria y contexto para conversaciones de IA.
  • Incluye mecanismos de manejo de errores para garantizar la confiabilidad.

Caso de uso

Un sistema de inteligencia artificial para la gestión de la nube donde diferentes agentes trabajan juntos para detectar y solucionar problemas del servidor de forma autónoma.

LangChain

LangChain es un framework popular que ayuda a los desarrolladores a crear aplicaciones de IA mediante la interconexión de indicaciones, memoria y diversas herramientas. Simplifica la integración de la IA en diferentes flujos de trabajo.

Características principales

  • Diseño modular para crear y gestionar flujos de trabajo de IA.
  • Memoria incorporada para permitir conversaciones con estado.
  • Compatibilidad con múltiples modelos de IA y API.

Caso de uso

Un chatbot para un banco que recupera detalles de los clientes y proporciona información basada en el historial de transacciones.

LangGraph

LangGraph amplía LangChain al introducir un enfoque gráfico para la gestión de flujos de trabajo. Este marco es útil para aplicaciones que requieren la ejecución de tareas paso a paso.

Características principales

  • Gestión de flujo de trabajo basada en gráficos para agentes de IA.
  • Maneja dependencias entre diferentes tareas de manera eficiente.
  • Admite procesos complejos de varios pasos.

Caso de uso

Una IA de diagnóstico médico que recupera el historial del paciente, analiza los síntomas y sugiere tratamientos en un flujo de trabajo estructurado.

Núcleo semántico de Microsoft

El núcleo semántico de Microsoft se centra en que los sistemas de IA comprendan mejor la intención y el contexto del usuario. Es especialmente útil para aplicaciones de IA que requieren un razonamiento semántico profundo.

Características principales

  • Toma de decisiones consciente del contexto para aplicaciones de IA.
  • Integraciones prediseñadas con herramientas y sistemas empresariales.
  • Comprensión semántica mejorada para una mayor precisión.

Caso de uso

Un servicio de asistencia informática impulsado por inteligencia artificial que comprende las consultas de los usuarios y sugiere las mejores soluciones en función de interacciones pasadas.

CrewAI

CrewAI está diseñado para la colaboración entre múltiples agentes. Permite a los agentes de IA asumir diferentes roles y trabajar en equipo para completar tareas eficientemente.

Características principales

  • Agentes de IA basados ​​en roles con tareas especializadas.
  • Herramientas y flujos de trabajo personalizables para diferentes casos de uso.
  • La ejecución de tareas puede ser secuencial o jerárquica.


Caso de uso

Un sistema de inteligencia artificial para la gestión logística donde los agentes planifican rutas de entrega y optimizan las operaciones del almacén de forma colaborativa.

Marco de trabajo agente PhiData

El marco Agentic de PhiData mejora los asistentes de IA al integrar memoria, conocimiento y herramientas para manejar tareas complejas.

Características principales

  • Memoria de IA para retener interacciones pasadas.
  • Acceso a múltiples fuentes de datos, incluidas bases de datos y archivos PDF.
  • Herramientas integradas para búsqueda web, resumen de documentos y ejecución de consultas.

Caso de uso

Un asistente de inteligencia artificial empresarial que recupera informes, responde consultas y automatiza el procesamiento de documentos.

Figura 1: El diagrama de flujo

Desarrollando una IA agente: una guía práctica para desarrolladores

El objetivo de este sistema es desarrollar un servicio multiagente basado en IA que clasifique automáticamente las consultas de los usuarios en diferentes categorías y las dirija a agentes de IA especializados para obtener las respuestas adecuadas. En concreto, el sistema clasifica las consultas en:

  • Preguntas relacionadas con el clima (atendidas por el agente del servicio meteorológico)
  • Consultas relacionadas con noticias (gestionadas por el agente de servicio de noticias)
  • Solicitudes de chistes (gestionadas por el agente de servicio de chistes)

Importación de dependencias

Comenzamos importando dependencias de la siguiente manera.

  • langgraph: se utiliza para gestionar flujos de trabajo y transiciones de estado.
  • time: Se utiliza para medir el rendimiento.
  • HuggingFaceHub y SystemMessage de langchain : para interactuar con el centro de modelos Hugging Face y trabajar con indicaciones.
  • StateGraph de langgraph: Para definir una máquina de estados que orquesta el flujo de diferentes agentes.
  • BaseModel de pydantic: para definir modelos de datos estructurados (por ejemplo, ExpertSystemState).
  • os: Para manejar variables de entorno, específicamente para configurar la clave API de Hugging Face.
import warnings
warnings.filterwarnings("ignore", category=FutureWarning)
 
import langgraph
import time
from langchain.llms import HuggingFaceHub
from langchain.schema import SystemMessage
from langgraph.graph import StateGraph 
from pydantic import BaseModel

import os

Ahora, configuramos la clave API de Hugging Face. Esto define la variable de entorno para tu token de API de Hugging Face para que puedas interactuar con el modelo. Reemplaza TU CLAVE AQUÍ por la CLAVE API real .

os.environ[“HUGGINGFACEHUB_API_TOKEN”] = “YOUR KEY HERE”

A continuación, se carga un modelo Hugging Face específico (Mistral-7B-Instruct-v0.1). La temperatura controla la aleatoriedad y max_length controla la longitud de las respuestas generadas. 

llm = HuggingFaceHub(
repo_id="mistralai/Mistral-7B-Instruct-v0.1",    # Public model
model_kwargs={"temperature": 0.7, "max_length": 256}
)

El esquema de estado define un modelo estructurado para el estado del sistema, que incluye: 

input_data: The user query.

category: The category of the query (e.g., weather, news, joke).
response: The response generated by the agent (e.g., weather forecast, news, joke).

class ExpertSystemState(BaseModel):
input_data: str        # User query
category: str = None   # Categorized question type
response: str = None   # AI-generated response

La función 'auxiliar' registra eventos durante el flujo de trabajo (como analizar una consulta, clasificar una consulta, etc.) con fines de depuración o seguimiento.

def log_event(step: str, message: str):
print(f”[{step}] {message}”)

Definición de los agentes de servicio

Cada agente corresponde a una categoría de consulta diferente. Así funciona cada agente.

  • Súper agente (función super_agent):
    • Analiza la consulta del usuario y la clasifica (clima, noticias o chistes).
    • Utiliza el modelo Hugging Face para clasificar la consulta según el mensaje.
  • Servicio meteorológico (función weather_service):
    • Proporciona información relacionada con el clima según la consulta.
  • Servicio de noticias (función news_service):
    • Proporciona las últimas noticias según la consulta.
  • Servicio de bromas (función joke_service):
  • Proporciona un chiste basado en la consulta.

Cada una de estas funciones genera una respuesta utilizando el modelo Hugging Face, la registra y devuelve el ExpertSystemState con la respuesta adecuada. 

def super_agent(state: ExpertSystemState) -> ExpertSystemState:
log_event("Super Agent", f"Analyzing query: {state.input_data}")
prompt = f"""
You are a Super Agent tasked with categorizing the query into one of the following categories:
- weather_service
- news_service- joke_service
Examples:Query: What is the weather forecast for today?
Category: weather_service
Query: What’s the latest news?
Category: news_service
Query: Tell me a joke.
Category: joke_service
Only return the category name.
Query: {state.input_data}
"""
classification = llm.invoke([SystemMessage(content=prompt)]).strip()
category = classification.split()[-1]
log_event("Super Agent", f"Classified as: {category}")
return ExpertSystemState(input_data=state.input_data, category=category)
def weather_service(state: ExpertSystemState) -> ExpertSystemState:
log_event("Weather Service Agent", f"Providing weather forecast for: {state.input_data}")
prompt = f"Provide the weather forecast for: {state.input_data}"
response = llm.invoke([SystemMessage(content=prompt)]).strip()
log_event("Weather Service Agent", f"Generated Response: {response}")
return ExpertSystemState(input_data=state.input_data, category=state.category, response=response)
def news_service(state: ExpertSystemState) -> ExpertSystemState:
log_event("News Service Agent", f"Providing latest news for: {state.input_data}")
prompt = f"Provide the latest news for: {state.input_data}"
response = llm.invoke([SystemMessage(content=prompt)]).strip()
log_event("News Service Agent", f"Generated Response: {response}")
return ExpertSystemState(input_data=state.input_data, category=state.category, response=response)
def joke_service(state: ExpertSystemState) -> ExpertSystemState:
log_event("Joke Service Agent", f"Telling a joke for: {state.input_data}")
prompt = f"Tell a joke for: {state.input_data}"
response = llm.invoke([SystemMessage(content=prompt)]).strip()
log_event("Joke Service Agent", f"Generated Response: {response}")
return ExpertSystemState(input_data=state.input_data, category=state.category, response=response)

El StateGraph se crea para generar el flujo de trabajo, que define el flujo de ejecución. Cada agente de servicio se añade como un nodo al grafo. 

workflow = StateGraph(state_schema=ExpertSystemState)
workflow.add_node("super_agent", super_agent)
workflow.add_node("weather_service", weather_service)
workflow.add_node("news_service", news_service)
workflow.add_node("joke_service", joke_service)

La función de decisión decide a qué servicio dirigir la consulta según la categoría (servicio meteorológico, servicio de noticias, servicio de bromas). Si no se encuentra la categoría, se usa el servicio meteorológico por defecto. 

def decision_function(state: ExpertSystemState):
routing = {
"weather_service": "weather_service",
"news_service": "news_service",
"joke_service": "joke_service"
}
return routing.get(state.category, "weather_service")
workflow.add_conditional_edges("super_agent", decision_function)

Para establecer puntos de entrada y salida del flujo de trabajo, utilice el siguiente código:

workflow.set_entry_point(“super_agent”)       # Start point
workflow.set_finish_point(“weather_service”)  # Possible endpoint
workflow.set_finish_point(“news_service”)     # Possible endpoint
workflow.set_finish_point(“joke_service”)     # Possible endpoint
app = workflow.compile()

Procesamiento de consultas de usuarios

Se define una lista de consultas de usuario. Estas se procesan una por una, como se indica a continuación.

  • El flujo de trabajo se invoca con la consulta como entrada.
  • Se obtiene y procesa la respuesta final.
  • Se registra el tiempo empleado en cada consulta.
# List of user queries (Very definite questions)
user_queries = [
"What’s the weather like today?",
"Tell me the latest news.",
"Can you tell me a joke?",
"What is today breaking news in Kolkata?"
]
for idx, query in enumerate(user_queries, start=1):
print(f"\n--- Processing Query {idx}/{len(user_queries)} ---")
start_time = time.time()
final_state = app.invoke(ExpertSystemState(input_data=query))
final_state = ExpertSystemState(**final_state
end_time = time.time()
log_event("Response Time", f"{round(end_time - start_time, 2)} seconds")
print("\nFinal Response:")
print(f"- User Query: {final_state.input_data}")
print(f"- Category: {final_state.category}")
print(f"- Final Response: {final_state.response}")
print("-" * 50)

La salida es: 

--- Processing Query 1/4 ---

[Super Agent] Analyzing query: What’s the weather like today?

[Super Agent] Classified as: weather_service

[Weather Service Agent] Providing weather forecast for: What’s the weather like today?

[Weather Service Agent] Generated Response: The weather forecast for today is sunny with a high of 25°C and a low of 15°C.

[Response Time] 0.42 seconds

Final Response:

- User Query: What’s the weather like today?

- Category: weather_service

- Final Response: The weather forecast for today is sunny with a high of 25°C and a low of 15°C.

--------------------------------------------------

--- Processing Query 2/4 ---

[Super Agent] Analyzing query: Tell me the latest news.

[Super Agent] Classified as: news_service

[News Service Agent] Providing latest news for: Tell me the latest news.

[News Service Agent] Generated Response: The latest news is that the stock market has reached an all-time high today.

[Response Time] 0.48 seconds

Final Response:

- User Query: Tell me the latest news.

- Category: news_service

- Final Response: The latest news is that the stock market has reached an all-time high today.

--------------------------------------------------

--- Processing Query 3/4 ---

[Super Agent] Analyzing query: Can you tell me a joke?

[Super Agent] Classified as: joke_service

[Joke Service Agent] Telling a joke for: Can you tell me a joke?

[Joke Service Agent] Generated Response: Why don’t scientists trust atoms? Because they make up everything!

[Response Time] 0.43 seconds

Final Response:

- User Query: Can you tell me a joke?

- Category: joke_service

- Final Response: Why don’t scientists trust atoms? Because they make up everything!

--------------------------------------------------

--- Processing Query 4/4 ---

[Super Agent] Analyzing query: What is today breaking news in Kolkata?

[Super Agent] Classified as: news_service

[News Service Agent] Providing latest news for: What is today breaking news in Kolkata?

[News Service Agent] Generated Response: Breaking news in Kolkata: A new metro line has been inaugurated today, enhancing the city’s public transport system.

[Response Time] 0.45 seconds

Final Response:

- User Query: What is today breaking news in Kolkata?

- Category: news_service

- Final Response: Breaking news in Kolkata: A new metro line has been inaugurated today, enhancing the city’s public transport system.

--------------------------------------------------
  • El Super Agente clasifica cada consulta (clima, noticias o chistes).
  • Según la clasificación, la consulta se envía al agente de servicio apropiado (clima, noticias o chistes).
  • Cada agente de servicio genera una respuesta, como un pronóstico del tiempo, una actualización de noticias o un chiste.
  • El sistema registra el tiempo necesario para procesar cada consulta y la respuesta final.
  • La salida muestra la respuesta final (consulta, categoría y respuesta generada) para cada consulta del usuario.

Un marco para futuros sistemas de IA

Las arquitecturas multiagente que permiten el aprendizaje adaptativo, la toma de decisiones dinámica y la integración fluida en diversos ecosistemas son el futuro de la IA. La arquitectura de IA agentica de próxima generación se compone de cinco capas integradas que posibilitan el funcionamiento general del sistema.

La capa de entrada recopila datos de las interacciones del usuario y las fuentes en tiempo real para permitir que el sistema se anticipe con inteligencia práctica. La capa de orquestación de agentes facilita la gestión adaptativa de tareas, las acciones colaborativas y la monitorización del rendimiento. En cada una de estas capas, los agentes han desarrollado funciones distintivas, como la planificación y la ejecución, la autoevaluación y la optimización del rendimiento, el uso de herramientas y el trabajo específico del dominio, o el aprendizaje y la mejora continua de los modelos de conocimiento. La capa de almacenamiento y recuperación de datos recibe almacenes centralizados y distribuidos, almacenes optimizados de vectores de acceso a la información y grafos de conocimiento enriquecidos con contexto que respaldan el razonamiento contextual. En la capa de salida, la información de IA se traduce en resultados individualizados y contextualizados, y actualiza continuamente las bases de conocimiento del sistema. La capa de servicio proporciona una capacidad de IA mejorada en todas las plataformas con recomendaciones cognitivas y garantía de cumplimiento normativo.

Este diseño también incluye salvaguardas para un uso seguro, responsable y conforme de la IA.

Los modelos de IA diseñados de esta manera pueden controlar cualquier sesgo, promover la equidad y la seguridad, y garantizar el cumplimiento de las regulaciones, asegurando así la solidez del sistema a largo plazo. Además, los modelos de IA de colaboración mejoran la funcionalidad general al permitir la interacción con sistemas externos.

No estás registrado para postear comentarios

Categoría: Inteligencia Artifical

Relacionados


Redes:


   

 

Suscribete / Newsletter

Suscribete a nuestras Newsletter y periódicamente recibirás un resumen de las noticias publicadas.

El Top de LinuxParty

Donar a LinuxParty

Probablemente te niegues, pero.. ¿Podrías ayudarnos con una donación?


Tutorial de Linux

Top 15 artículos por Fecha

Viendo artículos de: Octubre de 2025

Últimos comentarios

Filtro por Categorías

Designed by ExtreHost.