Escenarios de aplicación vertical de Agente de IA
Diferentes campos tienen diferentes requisitos y características para los agentes.
Mediante la personalización por dominio, los agentes pueden proporcionar servicios más especializados.
Agente de código
El agente de código es uno de los campos de aplicación de agentes más exitosos en la actualidad.
Puede comprender bases de código, escribir nuevo código y depurar problemas.
Capacidades principales
Autocompletado de código: Predecir el siguiente fragmento de código según el contexto.
Generación de código: Generar código a partir de descripciones en lenguaje natural.
Revisión de código: Detectar problemas y puntos de mejora en el código.
Localización de bugs: Analizar mensajes de error y localizar la causa raíz del problema.
Refactorización de código: Proponer y ejecutar sugerencias de optimización del código.
Sistemas representativos
| Sistema | Empresa de desarrollo | Características |
|---|---|---|
| GitHub Copilot | GitHub/OpenAI | Centrado en autocompletado de código, sugerencias en tiempo real |
| Claude Code | Anthropic | Asistente de línea de comandos, comprensión profunda de código |
| Devin | Cognition | Programación autónoma, ejecución de tareas de extremo a extremo |
| Cursor | Cursor | Editor de código con IA, integración profunda con IDE |
Ejemplo de implementación de código
Implementación de agente Text2SQL
"""
Text2SQL Agent
Convertir lenguaje natural a consultas SQL
"""
def __init__(self, llm, schema):
self.llm = llm
# Información del esquema de la base de datos
self.schema = schema
def convert(self, question):
"""
Convertir preguntas de lenguaje natural a SQL
:param question: pregunta en lenguaje natural
:return: sentencia de consulta SQL
"""
prompt = f"""
Eres un experto en SQL.
Esquema de la base de datos:
{self.schema}
Reglas:
1. Solo genera consultas SELECT (no se admiten INSERT/UPDATE/DELETE)
2. Usa alias de tabla razonables
3. Agrega las condiciones JOIN necesarias
4. Usa alias de columna claros
Pregunta: {question}
Por favor, genera la consulta SQL correspondiente.
"""
sql = self.llm.generate(prompt)
# Verificación de seguridad
return self.sanitize(sql)
def sanitize(self, sql):
"""
Verificación de seguridad SQL
Asegurar que no contenga operaciones peligrosas
"""
# Convertir a minúsculas para verificar
sql_lower = sql.lower().strip()
# Verificar que solo contenga SELECT
forbidden_keywords = [
"insert", "update", "delete", "drop",
"create", "alter", "truncate", "exec",
"execute", "grant", "revoke"
]
for keyword in forbidden_keywords:
if keyword in sql_lower:
raise ValueError(f"Palabra clave prohibida: {keyword}")
return sql
def execute(self, question, db_connection):
"""
Ejecutar consulta Text2SQL
"""
sql = self.convert(question)
cursor = db_connection.cursor()
cursor.execute(sql)
results = cursor.fetchall()
columns = [desc[0] for desc in cursor.description]
return {"columns": columns, "rows": results}
Agente de análisis de datos
El agente de análisis de datos puede comprender necesidades de datos, ejecutar consultas y generar informes de análisis.
Permite que personas no técnicas realicen análisis de datos complejos.
Capacidades principales
Comprensión de datos: Comprender la estructura de la base de datos y el significado de los datos.
Generación de consultas: Text2SQL, convertir lenguaje natural en consultas.
Visualización: Generar sugerencias y configuraciones de gráficos.
Generación de informes: Analizar resultados y generar informes en lenguaje natural.
Implementación de código
Implementación de agente de análisis de datos
"""
Agente de análisis de datos
Comprender necesidades de datos, ejecutar análisis, generar informes
"""
def __init__(self, llm, db_connection, chart_generator):
self.llm = llm
self.db = db_connection
self.chart_generator = chart_generator
def analyze(self, request):
"""
Procesar solicitudes de análisis de datos
"""
# Primer paso: comprender la necesidad de análisis
intent = self.parse_intent(request)
# Segundo paso: generar consulta
query = self.generate_query(intent)
# Tercer paso: ejecutar consulta
data = self.execute_query(query)
# Cuarto paso: analizar datos
analysis = self.perform_analysis(data, intent)
# Quinto paso: generar sugerencias de visualización
charts = self.suggest_charts(analysis)
# Sexto paso: generar informe
report = self.generate_report(analysis, charts)
return {
"intent": intent,
"query": query,
"data": data,
"analysis": analysis,
"charts": charts,
"report": report
}
def parse_intent(self, request):
"""Analizar la intención del usuario"""
prompt = f"""
Analiza la siguiente solicitud de datos y extrae la información clave:
Solicitud: {request}
Por favor, extrae:
1. Objetivo del análisis (comparación, tendencia, distribución, etc.)
2. Tablas y campos involucrados
3. Rango de tiempo (si existe)
4. Condiciones de filtrado (si existen)
"""
return self.llm.generate(prompt)
def generate_query(self, intent):
"""Generar consulta SQL"""
prompt = f"""
Genera una consulta SQL basada en la siguiente intención:
{intent}
Esquema de la base de datos:
{self.get_schema()}
"""
return self.llm.generate(prompt)
def execute_query(self, query):
"""Ejecutar consulta"""
cursor = self.db.cursor()
cursor.execute(query)
columns = [desc[0] for desc in cursor.description]
rows = cursor.fetchall()
return {"columns": columns, "rows": rows}
def perform_analysis(self, data, intent):
"""Ejecutar análisis de datos"""
# Implementación simplificada
import statistics
rows = data["rows"]
columns = data["columns"]
analysis = {
"row_count": len(rows),
"summary": {}
}
# Calcular estadísticas para columnas numéricas
for i, col in enumerate(columns):
if self.is_numeric(rows, i):
values = [row[i] for row in rows if row[i] is not None]
if values:
analysis["summary"][col] = {
"min": min(values),
"max": max(values),
"avg": statistics.mean(values),
"median": statistics.median(values)
}
return analysis
def suggest_charts(self, analysis):
"""Recomendar gráficos de visualización"""
suggestions = []
# Recomendar gráficos según el tipo de análisis
if "trend" in str(analysis).lower():
suggestions.append({
"type": "line",
"description": "Gráfico de líneas, adecuado para mostrar tendencias"
})
if "comparison" in str(analysis).lower():
suggestions.append({
"type": "bar",
"description": "Gráfico de barras, adecuado para comparar categorías"
})
suggestions.append({
"type": "table",
"description": "Tabla de datos, muestra datos detallados"
})
return suggestions
def generate_report(self, analysis, charts):
"""Generar informe de análisis"""
prompt = f"""
Basado en los siguientes resultados de análisis, genera un informe en lenguaje natural:
Resultado del análisis:
{analysis}
Gráficos recomendados:
{charts}
Por favor, genera un informe de análisis claro.
"""
return self.llm.generate(prompt)
Agente de atención al cliente
El agente de atención al cliente necesita manejar conversaciones de múltiples turnos, comprender la intención del usuario y proporcionar respuestas precisas.
Es uno de los escenarios más extendidos en la aplicación de IA.
Capacidades principales
Reconocimiento de intención: Comprender qué quiere hacer el usuario.
Relleno de ranuras (slot filling): Extraer información clave (tiempo, lugar, etc.).
Seguimiento del estado del diálogo: Gestionar el contexto de conversaciones de múltiples turnos.
Generación de respuestas: Generar respuestas naturales y profesionales.
Implementación de código
Implementación de agente de atención al cliente
"""
Agente de atención al cliente
Procesar consultas del usuario, proporcionar soporte de servicio
"""
def __init__(self, llm, knowledge_base, dialogue_manager):
self.llm = llm
# Base de conocimiento
self.knowledge_base = knowledge_base
# Administrador de diálogo
self.dialogue_manager = dialogue_manager
def handle(self, user_input, session_id):
"""
Procesar mensajes del usuario
"""
# Obtener historial de conversación
history = self.dialogue_manager.get_history(session_id)
# Reconocer intención del usuario
intent = self.recognize_intent(user_input, history)
# Procesar según la intención
if intent.type == "greeting":
response = self.handle_greeting()
elif intent.type == "inquiry":
response = self.handle_inquiry(intent)
elif intent.type == "complaint":
response = self.handle_complaint(intent)
elif intent.type == "order_status":
response = self.handle_order_status(intent)
elif intent.type == "refund":
response = self.handle_refund(intent)
else:
response = self.handle_general(user_input)
# Actualizar historial de conversación
self.dialogue_manager.add_message(
session_id,
{"role": "user", "content": user_input}
)
self.dialogue_manager.add_message(
session_id,
{"role": "assistant", "content": response}
)
return response
def recognize_intent(self, text, history):
"""Reconocer intención del usuario"""
prompt = f"""
Analiza el mensaje del usuario y reconoce el tipo de intención.
Mensaje actual: {text}
Historial de conversación:
{history}
Tipos de intención:
- greeting: saludo
- inquiry: consulta
- complaint: queja
- order_status: consulta de pedido
- refund: reembolso
- goodbye: despedida
Por favor, genera el tipo de intención y la confianza.
"""
result = self.llm.generate(prompt)
return Intent.parse(result)
def handle_inquiry(self, intent):
"""Manejar consulta"""
# Recuperar contenido relevante de la base de conocimiento
relevant_docs = self.knowledge_base.search(intent.query)
if relevant_docs:
# Si hay documentos relevantes, responder basado en ellos
prompt = f"""
Responde a la pregunta del usuario basándote en el siguiente documento.
Documento:
{relevant_docs}
Pregunta: {intent.query}
"""
return self.llm.generate(prompt)
else:
# Si no hay documentos relevantes, derivar al personal o registrar
return "Necesito investigar más sobre este tema, por favor espere, se lo consultaré."
class Intent:
"""Intención del usuario"""
def __init__(self, type, query, confidence):
self.type = type
self.query = query
self.confidence = confidence
@classmethod
def parse(cls, text):
"""Analizar texto de intención"""
# Implementación simplificada
return cls(type="inquiry", query=text, confidence=0.9)
Agente de investigación
El agente de investigación puede realizar investigaciones profundas de forma autónoma, recopilando y sintetizando información.
Simula la forma de trabajar de un investigador humano.
Capacidades principales
Planificación de búsqueda: Elaborar un plan de recopilación de información.
Recopilación de múltiples fuentes: Recopilar información de múltiples fuentes.
Verificación de información: Contrastar la exactitud de la información.
Generación de informes: Sintetizar información y generar informes estructurados.
Implementación de código
Implementación de agente de investigación
"""
Agente de investigación
Realiza investigaciones profundas de forma autónoma y genera informes.
"""
def __init__(self, search_tools, llm):
# Lista de herramientas de búsqueda
self.search_tools = search_tools
self.llm = llm
def research(self, topic, depth=3):
"""
Ejecutar tarea de investigación
:param topic: Tema de investigación
:param depth: Profundidad de investigación (número de rondas de búsqueda)
"""
# Primer paso: Elaborar el plan de investigación
plan = self.create_research_plan(topic, depth)
# Segundo paso: Ejecutar múltiples rondas de búsqueda
findings = []
for phase in plan.phases:
# Buscar en múltiples direcciones en paralelo
phase_results = self.search_phase(phase)
findings.extend(phase_results)
# Sintetizar los hallazgos actuales
synthesis = self.synthesize(findings)
findings.append({
"type": "synthesis",
"content": synthesis,
"phase": phase.number
})
# Tercer paso: Generar el informe final
report = self.generate_report(findings)
return {
"topic": topic,
"plan": plan,
"findings": findings,
"report": report
}
def create_research_plan(self, topic, depth):
"""Crear el plan de investigación"""
prompt = f"""
Elaborar un plan detallado para el siguiente tema de investigación:
Tema: {topic}
Profundidad: {depth}
Por favor, planifique:
1. Direcciones clave que deben investigarse (3-5)
2. Preguntas centrales que cada dirección debe responder
3. Sugerencias de fuentes de información
"""
return ResearchPlan.parse(self.llm.generate(prompt))
def search_phase(self, phase):
"""Ejecutar una sola fase de búsqueda"""
results = []
for query in phase.queries:
# Buscar usando la herramienta de búsqueda
for tool in self.search_tools:
search_results = tool.search(query)
results.extend(search_results)
return results
def synthesize(self, findings):
"""Sintetizar hallazgos"""
prompt = f"""
Sintetice los siguientes hallazgos de investigación y extraiga la información clave:
Lista de hallazgos:
{findings}
Por favor, extraiga:
1. Conclusiones principales
2. Evidencia que respalda las conclusiones
3. Controversias o incertidumbres existentes
4. Preguntas que requieren más investigación
"""
return self.llm.generate(prompt)
def generate_report(self, findings):
"""Generar el informe final"""
prompt = f"""
Genere un informe estructurado basado en los siguientes hallazgos de investigación:
Hallazgos de investigación:
{findings}
Requisitos del informe:
1. Resumen ejecutivo
2. Introducción
3. Hallazgos principales (por tema)
4. Conclusiones y recomendaciones
5. Fuentes de referencia
Por favor, genere el informe completo.
"""
return self.llm.generate(prompt)
class ResearchPlan:
"""Plan de investigación"""
@classmethod
def parse(cls, text):
"""Analizar el texto del plan"""
# Implementación simplificada
return cls(phases=[
ResearchPhase(number=1, queries=["Tema relacionado 1"], goals=["Comprender los conceptos básicos"]),
ResearchPhase(number=2, queries=["Tema relacionado 2"], goals=["Análisis en profundidad"]),
])
def __init__(self, phases):
self.phases = phases
class ResearchPhase:
"""Fase de investigación"""
def __init__(self, number, queries, goals):
self.number = number
self.queries = queries
self.goals = goals
Otras aplicaciones verticales
RPA + Agent
La combinación de RPA (Automatización Robótica de Procesos) con agentes.
Permite lograr una automatización más compleja de los procesos de negocio.
Los agentes otorgan a RPA capacidades de toma de decisiones inteligentes.
Agente NPC de juegos
Agente NPC (personaje no jugador) en juegos.
Capaz de realizar diálogos dinámicos, generación de tramas y juegos de rol.
Crea una experiencia de mundo de juego más realista.
Agente de investigación científica
AI for Science está cambiando la investigación científica.
Revisión bibliográfica: Leer y resumir automáticamente numerosos artículos.
Diseño experimental: Proponer planes experimentales e hipótesis.
Análisis de datos: Procesar datos experimentales y descubrir patrones.
Redacción de artículos: Asistir en la redacción de artículos de investigación.
Resumen del capítulo
Este capítulo presenta las aplicaciones de los agentes en diversos campos verticales.
Agente de códigoAsiste en la programación y mejora la eficiencia del desarrollo.
Agente de análisis de datosPermite que personas no técnicas también puedan analizar datos.
Agente de atención al clienteProporciona servicio al cliente inteligente.
Agente de investigaciónRealiza investigaciones profundas de forma autónoma.
También hay más escenarios como RPA+Agent, NPC de juegos, agente de investigación científica, etc.
Los agentes en campos verticales deben personalizarse combinando conocimiento del dominio.
Elegir el escenario y el punto de entrada adecuados es clave para una implementación exitosa.
Otras extensiones