Router

AI powered Switch

1. Descripción General

Épica: Router Heurístic

Épica: Router Heurístico Descripción: Un sistema que utiliza una colección de routers. Cada router tiene un agente ("Agent") y un arreglo de flujos ("Flows"). El código se genera usando agentbase-factory para crear rutas dinámicas en /router/:router-name y /router/:router-name/flows.

Uso: Los routers son invocados para ejecutar uno o más flujos según lo decida el agente, que elige qué flujos se ejecutan y en qué orden. Los routers pueden recibir uno o varios parámetros que serán interpretados por el agente para personalizar la ejecución de los flujos. Además, existe un endpoint para obtener la lista de flujos asociados a un router sin ejecutarlos. Ejemplos de flujos: web scraping, búsqueda en Google, búsqueda en YouTube. Modelo de Datos: Cada router está compuesto por:

• agent_id

• flows_ids[] (lista de flujos asociados)

• name (nombre del router)

• parámetros (inputs que recibe el router y que son interpretados por el agente)

2. UML 1: Modelado del Router Heurístico

+----------------+          +----------------+
|    Router      |<>------- |     Agent      |
+----------------+          +----------------+
| - agent_id     |          | - agent_id     |
| - flows_ids[]  |          | - name         |
| - name         |          | - description  |
| - params[]     |          |                |
| - execute()    |          +----------------+
+----------------+
        |                           |
        |                           |
        v                           v
  +------------------+         +------------------+
  |      Flow        |         |   DynamicResult   |
  +------------------+         +------------------+
  | - flow_id        |         | - result_data     |
  | - name           |         | - status          |
  | - description    |         | - generated_at    |
  | - order          |         +------------------+
  +------------------+
        |
        |
        v
+-------------------------------+
|          Endpoints           |
+-------------------------------+
| - /router/:router-name       |  (Ejecutar Flujos)
| - /router/:router-name/flows |  (Devolver Flujos)
+-------------------------------+

Explicación del UML 1 (Actualizado):

1. Router:

   • Atributos: Contiene agent_id, flows_ids[], name, params[].

   • execute(): Método encargado de ejecutar los flujos asociados al router.

2. Agent:

   • Decide qué flujos ejecutar y en qué orden, basándose en los parámetros recibidos del router.

3. Flow:

   • Representa una tarea que el agente puede ejecutar. Contiene flow_id, name, description, y order (orden de ejecución).

4. DynamicResult:

   • Contiene los resultados generados por los flujos (result_data), el estado (status), y el momento de generación (generated_at).

5. Endpoints:

   • /router/:router-name: Endpoint que ejecuta los flujos del router especificado, llamando al método execute().

   • /router/:router-name/flows: Endpoint que devuelve los flujos asociados al router sin ejecutarlos. Esto permite al cliente obtener información sobre los flujos disponibles.

Proceso:

• Cliente: Envía una solicitud al endpoint.

  • Para /router/:router-name, los flujos son ejecutados y el resultado es devuelto.

  • Para /router/:router-name/flows, el cliente obtiene una lista de los flujos sin ejecutarlos, incluyendo sus descripciones y el orden.

3. UML 2: Ejecución del Flujo (Actualizado)

Este diagrama UML muestra el proceso de ejecución de un router, desde la llamada a la ruta con parámetros hasta la obtención de los resultados dinámicos de los flujos:

+------------------+    /router/:router-name    +-------------------+
|     Client       |-------------------------->|       Router       |
+------------------+                           +-------------------+
|   params[]       |                            | - invoke Agent    |
                                                 v
                                          +--------------------+
                                          |       Agent         |
                                          +--------------------+
                                                | interpret params[]
                                                |  decide flow order
                                                v
                                          +--------------------+
                                          |     Flow[]         |
                                          +--------------------+
                                                | execute flows
                                                v
                                          +--------------------+
                                          |  DynamicResult[]    |
                                          | - result_data       |
                                          | - status            |
                                          +--------------------+
                                                | return results
                                                v
+------------------+    JSON Response          +-------------------+
|     Client       |<--------------------------|       Router       |
+------------------+                           +-------------------+

Explicación UML 2 (Ejecución del Flujo):

1. Client: El cliente realiza una solicitud HTTP a /router/:router-name enviando uno o varios parámetros (params[]).

2. Router: El router recibe la solicitud y los parámetros, y luego llama al agente asociado.

3. Agent: El agente interpreta los parámetros y toma decisiones sobre qué flujos ejecutar, en qué orden.

4. Flows: Los flujos son ejecutados en el orden indicado por el agente. Cada flujo genera un DynamicResult (resultado dinámico) con información como el estado (status) y los datos generados (result_data).

5. Router: El router recolecta los resultados de los flujos y los devuelve en una respuesta JSON al cliente.

6. Client: El cliente recibe un JSON con los resultados de la ejecución de los flujos.

4. Modelo de Datos

Tabla: router

Campo	Tipo de Dato	Descripción
id	INT	Identificador único del router
agent_id	INT	Identificador del agente asociado
flows_ids	ARRAY(INT)	Arreglo de identificadores de flujos
name	VARCHAR(255)	Nombre del router
params[]	ARRAY(JSON)	Parámetros que recibe el router

Tabla: agent

Campo	Tipo de Dato	Descripción
id	INT	Identificador único del agente
name	VARCHAR(255)	Nombre del agente
description	TEXT	Descripción breve del agente

Tabla: flow

Campo	Tipo de Dato	Descripción
id	INT	Identificador único del flujo
name	VARCHAR(255)	Nombre del flujo
description	TEXT	Descripción breve del flujo

Tabla: dynamic_result

Campo	Tipo de Dato	Descripción
result_id	INT	Identificador único del resultado
result_data	JSON	Datos generados dinámicamente
status	VARCHAR(50)	Estado del resultado (ej. éxito, fallo)
generated_at	TIMESTAMP	Fecha y hora en que se generó el resultado

5. Pruebas de Estrés

Escenarios de Pruebas de Estrés:

1. Carga de Flujos Concurrentes: Simular la ejecución de hasta 10,000 routers simultáneos y medir el rendimiento.

2. Sobrecarga de Input: Introducir grandes volúmenes de datos como input del agente y parámetros del router para verificar que los resultados dinámicos se generan sin errores.

3. Simulación de Errores Masivos: Enviar inputs malformados a 1000 routers simultáneamente para observar cómo maneja el sistema los errores.

4. Prueba de Escalabilidad: Medir el rendimiento al escalar desde 100 hasta 10,000 routers activos.

6. Pruebas de Integración

Escenarios de Pruebas de Integración:

1. Integración Router-Agent: Verificar la correcta interacción entre el router y el agente, asegurando que los parámetros sean interpretados correctamente.

2. Integración Router-Flows: Verificar que los flujos seleccionados por el agente se ejecuten en el orden correcto, basado en los parámetros recibidos.

3. Validación de Resultados Dinámicos: Asegurar que los resultados generados dinámicamente reflejan el estado correcto basado en los inputs del agente y los parámetros recibidos.

4. Simulación Completa: Simular un flujo completo de ejecución desde la creación del router hasta la devolución de los resultados al cliente, incluyendo los parámetros recibidos por el router.