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

class Text2SQLAgent:
    """
    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

class DataAnalysisAgent:
    """
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

class CustomerServiceAgent:
    """
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

class ResearchAgent:
    """
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