Translation Not Available Yet

 

     

Discord · 𝕏 · LinkedIn

🎉 Anuncio: API de Respuestas Abiertas de Julep (Alpha)

Julep es una plataforma sin servidor que ayuda a equipos de datos y ML a construir flujos de trabajo de IA sofisticados. Proporciona una base robusta para orquestar operaciones complejas de IA, gestionar estados entre interacciones e integrarse con tu infraestructura y herramientas de datos existentes.

Ya sea que estés construyendo pipelines de datos o creando flujos de trabajo de IA, Julep facilita la composición y escalabilidad de flujos de trabajo impulsados por LLM sin gestionar infraestructura. Imagina que quieres construir un agente de IA que pueda hacer más que responder preguntas simples: necesita manejar tareas complejas, recordar interacciones pasadas y quizás incluso usar otras herramientas o APIs. Ahí es donde entra Julep. Nuestra plataforma maneja el trabajo pesado para que puedas enfocarte en construir soluciones inteligentes para tu negocio.

💡 Para aprender más sobre Julep, consulta la Documentación.

📖 Tabla de Contenidos

• ✨ Características Clave
• 🧠 Modelo Mental
• 📦 Instalación
  • 🛠️ SDKs de Julep
  • 🛠️ CLI de Julep
• 🚀 Inicio Rápido
  • ¿Qué sigue?
• 🔍 Referencia
  • 📚 Referencia del SDK
  • 🛠️ Referencia de la API
• 💻 Configuración Local
  • 1. Clonar el Repositorio
  • 2. Navegar al Directorio Raíz
  • 3. Configurar Variables de Entorno
  • 4. Crear un Volumen de Docker para Copia de Seguridad
  • 5. Ejecutar el Proyecto usando Docker Compose
  • 6. Interacción
  • 7. Solución de Problemas
• 👥 Contribuidores
  • ¡Únete a Nuestra Comunidad! 🌟
• 📄 Licencia

✨ Características Clave

💡 Para aprender más sobre Julep, consulta la Documentación.

🧠 Modelo Mental

Julep está compuesto por los siguientes componentes:

• Plataforma Julep: La plataforma Julep es un servicio en la nube que ejecuta tus flujos de trabajo. Incluye un lenguaje para describir flujos de trabajo, un servidor para ejecutarlos y un SDK para interactuar con la plataforma.
• SDKs de Julep: Los SDKs de Julep son un conjunto de bibliotecas para construir flujos de trabajo. Hay SDKs para Python y JavaScript, con más en camino.
• CLI de Julep: La CLI de Julep es una herramienta de línea de comandos que te permite interactuar con la plataforma Julep directamente desde tu terminal.
• API de Julep: La API de Julep es una API RESTful que puedes usar para interactuar con la plataforma Julep.

Piensa en Julep como una plataforma que combina componentes tanto del lado del cliente como del servidor para ayudarte a construir agentes de IA avanzados. Así es como puedes visualizarlo:

1. Tu Código de Aplicación:

   • Puedes usar el SDK de Julep en tu aplicación para definir agentes, tareas y flujos de trabajo.
   • El SDK proporciona funciones y clases que facilitan la configuración y gestión de estos componentes.
   • Puedes usar la CLI de Julep para interactuar con la plataforma Julep directamente desde tu terminal.

2. Servicio Backend de Julep:

   • El SDK se comunica con el backend de Julep a través de la red.
   • La CLI se comunica con el backend de Julep a través del SDK.
   • El backend maneja la ejecución de tareas, mantiene el estado de la sesión, almacena documentos y orquesta flujos de trabajo.

3. Integración con Herramientas y APIs:

   • Dentro de tus flujos de trabajo, puedes integrar herramientas y servicios externos.
   • El backend facilita estas integraciones, permitiendo que tus agentes realicen búsquedas web, accedan a bases de datos o llamen a APIs de terceros.

📦 Instalación

  npm install @julep/sdk

  # or

  bun add @julep/sdk

  pip install julep

🛠️ CLI de Julep

La CLI de Julep es una herramienta de línea de comandos que te permite interactuar con la plataforma Julep directamente desde tu terminal. Proporciona una forma conveniente de gestionar tus flujos de trabajo de IA, tareas y agentes sin necesidad de escribir código.

pip install julep-cli

Para más detalles, consulta la Documentación de la CLI de Julep.

[!NOTE] La CLI está actualmente en beta y disponible solo para Python. ¡Próximamente soporte para Node.js!

🚀 Inicio Rápido

Imagina un agente de investigación de IA que pueda hacer lo siguiente:

1. Tomar un tema,
2. Generar 30 consultas de búsqueda para ese tema,
3. Realizar esas búsquedas web en paralelo,
4. Resumir los resultados,
5. Enviar el resumen a Discord.

[!NOTE] En Julep, esto sería una sola tarea con menos de 80 líneas de código y se ejecutaría completamente gestionado por sí solo. Todos los pasos se ejecutan en los servidores de Julep y no necesitas hacer nada.

Aquí tienes un ejemplo completo de una definición de tarea:

# yaml-language-server: $schema=https://raw.githubusercontent.com/julep-ai/julep/refs/heads/dev/schemas/create_task_request.json
name: Research Agent
description: A research assistant that can search the web and send the summary to Discord
########################################################
####################### INPUT ##########################
########################################################

# Define the input schema for the task
input_schema:
  type: object
  properties:
    topic:
      type: string
      description: The main topic to research
    num_questions:
      type: integer
      description: The number of search queries to generate

########################################################
####################### TOOLS ##########################
########################################################

# Define the tools that the agent can use
tools:
  - name: web_search
    type: integration
    integration:
      provider: brave
      setup:
        api_key: "<your-brave-api-key>"

  - name: discord_webhook
    type: api_call
    api_call:
      url: https://discord.com/api/webhooks/<your-webhook-id>/<your-webhook-token>
      method: POST
      headers:
        Content-Type: application/json

########################################################
####################### MAIN WORKFLOW #################
########################################################

# Special variables:
# - steps[index].input: for accessing the input to the step at that index
# - steps[index].output: for accessing the output of the step at that index
# - _: for accessing the output of the previous step

# Define the main workflow
main:
# Step 0: Generate search queries
- prompt:
    - role: system
      content: >-
        $ f"""
        You are a research assistant.
        Generate {{steps[0].input.num_questions|default(30, true)}} diverse search queries related to the topic:
        {steps[0].input.topic}

        Write one query per line.
        """
  unwrap: true

# Step 1: Evaluate the search queries using a simple python expression
- evaluate:
    search_queries: $ _.split(NEWLINE)

# Step 2: Run the web search in parallel for each query
- over: $ _.search_queries
  map:
    tool: web_search
    arguments:
      query: $ _
  parallelism: 5

# Step 3: Collect the results from the web search
- evaluate:
    search_results: $ _

# Step 4: Summarize the results
- prompt:
    - role: system
      content: >
        $ f"""
        You are a research summarizer. Create a comprehensive summary of the following research results on the topic {steps[0].input.topic}.
        The summary should be well-structured, informative, and highlight key findings and insights. Keep the summary concise and to the point.
        The length of the summary should be less than 150 words.
        Here are the search results:
        {_.search_results}
        """
  unwrap: true
  settings:
    model: gpt-4o-mini

# Step 5: Send the summary to Discord
- evaluate:
    discord_message: |-
      $ f'''
      **Research Summary for {steps[0].input.topic}**
      {_}
      '''

# Step 6: Send the summary to Discord
- tool: discord_webhook
  arguments:
    json_: 
      content: $ _.discord_message[:2000] # Discord has a 2000 character limit

Aquí puedes ejecutar el flujo de trabajo anterior usando el SDK de Julep:

from julep import Client
import yaml
import time

# Initialize the client
client = Client(api_key=JULEP_API_KEY)

# Create the agent
agent = client.agents.create(
  name="Julep Browser Use Agent",
  description="A Julep agent that can use the computer tool to interact with the browser.",
)

# Load the task definition
with open('./research_agent.yaml', 'r') as file:
  task_definition = yaml.safe_load(file)

# Create the task
task = client.tasks.create(
  agent_id=agent.id,
  **task_definition
)

# Create the execution
execution = client.executions.create(
    task_id=task.id,
    input={
        "topic": "artificial intelligence",
        "num_questions": 30
    }
)

# Wait for the execution to complete
while (result := client.executions.get(execution.id)).status not in ['succeeded', 'failed']:
    print(result.status)
    time.sleep(1)

# Print the result
if result.status == "succeeded":
    print(result.output)
else:
    print(f"Error: {result.error}")

import { Julep } from '@julep/sdk';
import yaml from 'yaml';
import fs from 'fs';

// Initialize the client
const client = new Julep({
  apiKey: 'your_julep_api_key'
});

// Create the agent
const agent = await client.agents.create({
  name: "Julep Browser Use Agent",
  description: "A Julep agent that can use the computer tool to interact with the browser.",
});

// Parse the task definition
const taskDefinition = yaml.parse(fs.readFileSync('./research_agent.yaml', 'utf8'));

// Create the task
const task = await client.tasks.create(
  agent.id,
  taskDefinition
);

// Create the execution
const execution = await client.executions.create(
  task.id,
  {
    input: { 
      "topic": "artificial intelligence",
      "num_questions": 30
    }
  }
);

// Wait for the execution to complete
let result;
while (true) {
  result = await client.executions.get(execution.id);
  if (result.status === 'succeeded' || result.status === 'failed') break;
  console.log(result.status);
  await new Promise(resolve => setTimeout(resolve, 1000));
}

// Print the result
if (result.status === 'succeeded') {
  console.log(result.output);
} else {
  console.error(`Error: ${result.error}`);
}

En este ejemplo, Julep gestionará automáticamente ejecuciones en paralelo, reintentos de pasos fallidos, reenvío de solicitudes API y mantendrá las tareas ejecutándose de manera confiable hasta su finalización.

Esto se ejecuta en menos de 30 segundos y devuelve el siguiente resultado:

¿Qué sigue?

• 📚 Explora más ejemplos en nuestro Libro de Recetas
• 🔧 Aprende sobre Integración de Herramientas
• 🧠 Entiende la Memoria del Agente
• 🔄 Profundiza en Flujos de Trabajo Complejos

[!TIP] 💡 Consulta más tutoriales en la sección Tutoriales de la documentación.

💡 Si eres principiante, recomendamos comenzar con la Guía de Inicio Rápido.

💡 Si buscas más ideas, revisa la sección Ideas del repositorio.

💡 Si prefieres recetas estilo libro de cocina, revisa la sección Libro de Recetas del repositorio.

🔍 Referencia

📚 Referencia del SDK

• Node.js Referencia del SDK | Paquete NPM
• Python Referencia del SDK | Paquete PyPI

🛠️ Referencia de la API

Explora nuestra documentación de API para aprender más sobre agentes, tareas, herramientas y la CLI de Julep aquí: Referencia de la API

💻 Configuración Local

1. Clonar el Repositorio

Clona el repositorio desde tu fuente preferida:

git clone <repository_url>

2. Navegar al Directorio Raíz

Cambia al directorio raíz del proyecto:

cd <repository_root>

3. Configurar Variables de Entorno

• Crea un archivo .env en el directorio raíz.
• Consulta el archivo .env.example para una lista de variables requeridas.
• Asegúrate de que todas las variables necesarias estén configuradas en el archivo .env.

4. Crear un Volumen de Docker para Copia de Seguridad

Crea un volumen de Docker llamado grafana_data, memory_store_data, temporal-db-data, prometheus_data, seaweedfs_data:

docker volume create grafana_data
docker volume create memory_store_data
docker volume create temporal-db-data
docker volume create prometheus_data
docker volume create seaweedfs_data

5. Ejecutar el Proyecto usando Docker Compose

Puedes ejecutar el proyecto en dos modos diferentes: Single Tenant o Multi-Tenant. Elige uno de los siguientes comandos según tu requerimiento:

1. Modo Single-Tenant

Ejecuta el proyecto en modo single-tenant:

docker compose --env-file .env --profile temporal-ui --profile single-tenant --profile self-hosted-db --profile blob-store --profile temporal-ui-public up --build --force-recreate --watch

Nota: En modo single-tenant, puedes interactuar con el SDK directamente sin necesidad de una API KEY.

2. Modo Multi-Tenant

Ejecuta el proyecto en modo multi-tenant:

docker compose --env-file .env --profile temporal-ui --profile multi-tenant --profile embedding-cpu --profile self-hosted-db --profile blob-store --profile temporal-ui-public up --force-recreate --build --watch

Nota: En modo multi-tenant, necesitas generar un token JWT localmente que actúe como API KEY para interactuar con el SDK.

Generar un Token JWT (Solo para Modo Multi-Tenant)

Para generar un token JWT, se requiere jwt-cli. Instálalo antes de proceder con los siguientes pasos.

Usa el siguiente comando y reemplaza JWT_SHARED_KEY con la clave correspondiente de tu archivo .env para generar un token JWT:

jwt encode --secret JWT_SHARED_KEY --alg HS512 --exp=$(date -d '+10 days' +%s) --sub '00000000-0000-0000-0000-000000000000' '{}'

Este comando genera un token JWT que será válido por 10 días.

6. Interacción

• Temporal UI: Puedes acceder a la UI de Temporal a través del puerto especificado en tu archivo .env.
• SDK de Julep: El SDK de Julep es una biblioteca Python/Node.js que te permite interactuar con la API de Julep.

from julep import Client

client = Client(api_key="your_jwt_token")

Nota: En el SDK en modo multi-tenant, necesitas generar un token JWT localmente que actúe como API KEY para interactuar con el SDK. Además, al inicializar el cliente, deberás configurar el entorno a local_multi_tenant y la api key al token JWT generado en el paso anterior. Mientras que en modo single-tenant puedes interactuar con el SDK directamente sin necesidad de API KEY y configurar el entorno a local.

7. Solución de Problemas

• Asegúrate de que todas las imágenes de Docker requeridas estén disponibles.
• Verifica variables de entorno faltantes en el archivo .env.
• Usa el comando docker compose logs para ver registros detallados para depuración.

👥 Contribuidores

¡Únete a Nuestra Comunidad! 🌟

¡Estamos emocionados de dar la bienvenida a nuevos contribuidores al proyecto Julep! Hemos creado varios "good first issues" para ayudarte a comenzar.

Cómo Contribuir:

1. 📖 Revisa nuestro archivo CONTRIBUTING.md para pautas
2. 🔍 Explora nuestros good first issues
3. 💬 Únete a nuestro Discord para ayuda y discusiones

Tus contribuciones, grandes o pequeñas, son valiosas para nosotros. ¡Construyamos algo increíble juntos! 🚀

Nuestros Increíbles Contribuidores:

📄 Licencia

Julep está licenciado bajo la Apache License 2.0.

Consulta el archivo LICENSE para más detalles.