Translation Not Available Yet

 

     

Discord · 𝕏 · LinkedIn

🎉 Annonce : API Open Responses de Julep (Alpha)

Julep est une plateforme serverless qui aide les équipes Data et ML à construire des flux de travail AI sophistiqués. Elle fournit une base robuste pour orchestrer des opérations AI complexes, gérer l'état entre les interactions et s'intégrer à votre infrastructure et outils de données existants.

Que vous construisiez des pipelines de données ou des flux de travail AI, Julep facilite la composition et la mise à l'échelle de workflows alimentés par LLM sans gérer d'infrastructure. Imaginez vouloir construire un agent AI capable de faire plus que répondre à des questions simples - il doit gérer des tâches complexes, se souvenir des interactions passées et peut-être même utiliser d'autres outils ou APIs. C'est là que Julep intervient. Notre plateforme gère les tâches complexes pour que vous puissiez vous concentrer sur la construction de solutions intelligentes pour votre entreprise.

💡 Pour en savoir plus sur Julep, consultez la Documentation.

📖 Table des matières

• ✨ Fonctionnalités clés
• 🧠 Modèle mental
• 📦 Installation
  • 🛠️ SDKs Julep
  • 🛠️ CLI Julep
• 🚀 Démarrage rapide
  • Et ensuite ?
• 🔍 Référence
  • 📚 Référence SDK
  • 🛠️ Référence API
• 💻 Configuration locale
  • 1. Cloner le dépôt
  • 2. Naviguer vers le répertoire racine
  • 3. Configurer les variables d'environnement
  • 4. Créer un volume Docker pour la sauvegarde
  • 5. Exécuter le projet avec Docker Compose
  • 6. Interaction
  • 7. Dépannage
• 👥 Contributeurs
  • Rejoignez notre communauté ! 🌟
• 📄 Licence

✨ Fonctionnalités clés

💡 Pour en savoir plus sur Julep, consultez la Documentation.

🧠 Modèle mental

Julep est composé des éléments suivants :

• Plateforme Julep : Service cloud qui exécute vos workflows. Inclut un langage pour décrire les workflows, un serveur pour les exécuter et un SDK pour interagir avec la plateforme.
• SDKs Julep : Bibliothèques pour construire des workflows. Disponibles pour Python et JavaScript, avec d'autres à venir.
• CLI Julep : Outil en ligne de commande pour interagir directement avec la plateforme Julep.
• API Julep : API RESTful pour interagir avec la plateforme Julep.

Considérez Julep comme une plateforme combinant composants client et serveur pour construire des agents AI avancés. Voici comment le visualiser :

1. Votre code d'application :

   • Utilisez le SDK Julep pour définir agents, tâches et workflows.
   • Le SDK fournit fonctions et classes pour configurer et gérer ces composants.
   • Utilisez le CLI Julep pour interagir directement avec la plateforme.

2. Service backend Julep :

   • Le SDK communique avec le backend Julep via le réseau.
   • Le CLI communique via le SDK.
   • Le backend gère l'exécution des tâches, maintient l'état des sessions, stocke les documents et orchestre les workflows.

3. Intégration avec outils et APIs :

   • Dans vos workflows, intégrez outils et services externes.
   • Le backend facilite ces intégrations, permettant à vos agents d'effectuer des recherches web, accéder à des bases de données ou appeler des APIs tierces.

📦 Installation

  npm install @julep/sdk

  # or

  bun add @julep/sdk

  pip install julep

🛠️ CLI Julep

Le CLI Julep est un outil en ligne de commande permettant d'interagir directement avec la plateforme Julep. Il offre un moyen pratique de gérer vos workflows, tâches et agents AI sans écrire de code.

pip install julep-cli

Pour plus de détails, consultez la Documentation du CLI Julep.

[!NOTE] Le CLI est actuellement en bêta et disponible uniquement pour Python. Le support Node.js arrive bientôt !

🚀 Démarrage rapide

Imaginez un agent de recherche AI capable de :

1. Prendre un sujet,
2. Générer 30 requêtes de recherche sur ce sujet,
3. Effectuer ces recherches web en parallèle,
4. Résumer les résultats,
5. Envoyer le résumé sur Discord.

[!NOTE] Avec Julep, ce serait une seule tâche en moins de 80 lignes de code s'exécutant entièrement gérée sans intervention. Toutes les étapes s'exécutent sur les serveurs de Julep sans effort de votre part.

Voici un exemple complet de définition de tâche :

# 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

Voici comment exécuter ce workflow avec le SDK 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}`);
}

Dans cet exemple, Julep gère automatiquement les exécutions parallèles, les nouvelles tentatives, les requêtes API et maintient les tâches jusqu'à leur achèvement.

Cela s'exécute en moins de 30 secondes et retourne :

Et ensuite ?

• 📚 Explorez plus d'exemples dans notre Cookbook
• 🔧 Découvrez l'Intégration d'outils
• 🧠 Comprenez la Mémoire des agents
• 🔄 Plongez dans les Workflows complexes

[!TIP] 💡 Consultez plus de tutoriels dans la section Tutoriels de la documentation.

💡 Si vous êtes débutant, nous recommandons de commencer par le Guide de démarrage rapide.

💡 Pour plus d'idées, consultez la section Idées du dépôt.

💡 Pour des recettes de type cookbook, consultez la section Cookbook.

🔍 Référence

📚 Référence SDK

• Node.js Référence SDK | Package NPM
• Python Référence SDK | Package PyPI

🛠️ Référence API

Explorez notre documentation API pour en savoir plus sur les agents, tâches, outils et le CLI Julep : Référence API

💻 Configuration locale

1. Cloner le dépôt

Clonez le dépôt depuis votre source préférée :

git clone <repository_url>

2. Naviguer vers le répertoire racine

Allez dans le répertoire racine du projet :

cd <repository_root>

3. Configurer les variables d'environnement

• Créez un fichier .env dans le répertoire racine.
• Référez-vous au fichier .env.example pour la liste des variables requises.
• Assurez-vous que toutes les variables nécessaires sont définies dans .env.

4. Créer un volume Docker pour la sauvegarde

Créez un volume Docker nommé 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. Exécuter le projet avec Docker Compose

Vous pouvez exécuter le projet en deux modes : Single Tenant ou Multi-Tenant. Choisissez une des commandes suivantes selon votre besoin :

1. Mode Single-Tenant

Exécutez le projet en mode 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

Note : En mode single-tenant, vous pouvez interagir directement avec le SDK sans clé API.

2. Mode Multi-Tenant

Exécutez le projet en mode 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

Note : En mode multi-tenant, vous devez générer un token JWT localement servant de clé API pour interagir avec le SDK.

Générer un token JWT (Mode Multi-Tenant uniquement)

Pour générer un token JWT, jwt-cli est requis. Installez-le avant de procéder.

Utilisez la commande suivante en remplaçant JWT_SHARED_KEY par la clé correspondante de votre .env pour générer un token JWT :

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

Cette commande génère un token JWT valable 10 jours.

6. Interaction

• UI Temporal : Accessible via le port spécifié dans votre .env.
• SDK Julep : Bibliothèque Python/Node.js pour interagir avec l'API Julep.

from julep import Client

client = Client(api_key="your_jwt_token")

Note : En mode multi-tenant, vous devez fournir le token JWT comme clé API et définir l'environnement sur local_multi_tenant. En mode single-tenant, définissez simplement l'environnement sur local sans clé API.

7. Dépannage

• Vérifiez que toutes les images Docker requises sont disponibles.
• Contrôlez les variables manquantes dans .env.
• Utilisez docker compose logs pour voir les logs de débogage.

👥 Contributeurs

Rejoignez notre communauté ! 🌟

Nous sommes ravis d'accueillir de nouveaux contributeurs sur Julep ! Nous avons créé des "good first issues" pour vous aider à démarrer.

Comment contribuer :

1. 📖 Lisez notre CONTRIBUTING.md
2. 🔍 Parcourez nos good first issues
3. 💬 Rejoignez notre Discord pour discuter

Vos contributions, grandes ou petites, nous sont précieuses. Construisons ensemble quelque chose d'incroyable ! 🚀

Nos incroyables contributeurs :

📄 Licence

Julep est sous licence Apache License 2.0.

Consultez le fichier LICENSE pour plus de détails.