Mejorar la experiencia del desarrollador para implementar distintas

[complexluise]

Implementar API de doble capa para mejorar la experiencia del desarrollador

Resumen

Se propone implementar una API de doble capa en nuestra librería ETL para documentos, LLMs y grafos de conocimiento. Esta aproximación combinará una interfaz declarativa basada en YAML con una API fluida en Python, ofreciendo así flexibilidad y facilidad de uso para una amplia gama de desarrolladores.

Motivación

Nuestra librería debe ser accesible para usuarios con diferentes niveles de experiencia y necesidades. Una API de doble capa permitirá:

1. Facilitar la adopción rápida para casos de uso comunes.
2. Proporcionar flexibilidad para escenarios más complejos o personalizados.
3. Mejorar la experiencia general del desarrollador, independientemente de su nivel de experiencia.

Propuesta

Implementar dos capas de API:

1. Capa Declarativa (YAML):

   • Interfaz principal para casos de uso estándar.
   • Configuración basada en YAML para definir pipelines ETL.
   • Fácil de entender, modificar y compartir.

2. Capa Fluida (Python API):

   • API fluida para construcción programática de pipelines.
   • Mayor control y flexibilidad para usuarios avanzados.
   • Permite inserción de lógica personalizada entre pasos del pipeline.

3. Interoperabilidad:

   • Proporcionar utilidades para convertir entre representaciones YAML y objetos de API fluida.
   • Permitir a los usuarios comenzar con YAML y migrar a la API fluida según sea necesario.

Ejemplos de uso

Capa Declarativa (YAML)

input:
  type: document
  source: /path/to/documents

steps:
  - name: text_extraction
    type: pdf_extractor
    config:
      language: es

  - name: preprocessing
    type: text_preprocessor
    config:
      lowercase: true
      remove_punctuation: true

  # ... [otros pasos] ...

output:
  type: neo4j
  config:
    uri: bolt://localhost:7687
    user: neo4j
    password: ${NEO4J_PASSWORD}

Uso en Python:

from etl_library import ETLPipeline

pipeline = ETLPipeline("pipeline_config.yaml")
pipeline.run()

Capa Fluida (Python API)

from etl_library import ETLPipeline, extractors, processors, loaders

pipeline = (
    ETLPipeline()
    .extract(
        extractors.PDFExtractor("/path/to/documents", language="es")
    )
    .process(
        processors.TextPreprocessor(lowercase=True, remove_punctuation=True)
    )
    .process(
        processors.SentenceChunker(max_length=100, overlap=20)
    )
    # ... [otros pasos] ...
    .load(
        loaders.Neo4jLoader(
            uri="bolt://localhost:7687",
            user="neo4j",
            password="password"
        )
    )
)

results = pipeline.run()

Tareas

• Diseñar e implementar la estructura de configuración YAML
• Desarrollar el parser YAML y el generador de pipelines
• Implementar la API fluida en Python
• Crear utilidades de conversión entre YAML y objetos de API fluida
• Desarrollar documentación y ejemplos para ambas capas
• Implementar pruebas unitarias y de integración para ambas APIs
• Crear tutoriales y guías de migración entre las dos capas

Beneficios esperados

• Mayor adopción de la librería debido a su facilidad de uso inicial
• Flexibilidad para usuarios avanzados sin comprometer la simplicidad para principiantes
• Mejor mantenibilidad y evolución de los pipelines ETL
• Experiencia de desarrollador mejorada, adaptándose a diferentes estilos y necesidades

Discusión

¿Qué otros aspectos deberíamos considerar para mejorar aún más la experiencia del desarrollador con esta aproximación de doble capa?