Explorer les documents · Discorde · 𝕏 · LinkedIn

[!REMARQUE] 👨‍💻 Vous êtes ici pour l'événement devfest.ai ? Rejoignez notre Discord et consultez les détails ci-dessous.

Obtenez votre clé API ici.

🌟 Contributeurs et participants au DevFest.AI(Cliquez pour agrandir)

🌟 Appel aux contributeurs !

Nous sommes ravis d'accueillir de nouveaux contributeurs au projet Julep ! Nous avons créé plusieurs « bons premiers numéros » pour vous aider à démarrer. Voici comment vous pouvez contribuer :

Consultez notre fichier CONTRIBUTING.md pour obtenir des instructions sur la façon de contribuer.
Parcourez nos bons premiers numéros pour trouver une tâche qui vous intéresse.
Si vous avez des questions ou avez besoin d'aide, n'hésitez pas à nous contacter sur notre chaîne Discord.

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

🎉 DevFest.AI octobre 2024

Des nouvelles passionnantes ! Nous participons au DevFest.AI tout au long du mois d'octobre 2024 ! 🗓️

Contribuez à Julep pendant cet événement et obtenez une chance de gagner de superbes produits et cadeaux Julep ! 🎁
Rejoignez des développeurs du monde entier pour contribuer aux référentiels d'IA et participer à des événements incroyables.
Un grand merci à DevFest.AI pour l'organisation de cette fantastique initiative !

[!TIP] Prêt à vous joindre à la fête ? Tweetez que vous participez et commençons à coder ! 🖥️

📖 Table of Contents

Introduction
Principales caractéristiques
Exemple rapide
Installation
Démarrage rapide de Python 🐍
Node.js Quick Start 🟩
- Step 1: Create an Agent
Components
- Mental Model
Concepts
Understanding Tasks
- Lifecycle of a Task
- Types of Workflow Steps
Tool Types
Integrations
Other Features
Référence
- Référence du SDK
- Référence API
Démarrage rapide local
Quelle est la différence entre Julep et LangChain etc ?

Introduction

Julep est une plateforme permettant de créer des agents IA qui se souviennent des interactions passées et peuvent effectuer des tâches complexes. Elle offre une mémoire à long terme et gère des processus en plusieurs étapes.

Julep permet la création de tâches en plusieurs étapes intégrant la prise de décision, les boucles, le traitement parallèle et l'intégration avec de nombreux outils et API externes.

Alors que de nombreuses applications d'IA se limitent à des chaînes simples et linéaires d'invites et d'appels d'API avec une ramification minimale, Julep est conçu pour gérer des scénarios plus complexes qui :

comporter plusieurs étapes,
prendre des décisions basées sur les résultats du modèle,
générer des branches parallèles,
utiliser beaucoup d'outils, et
courir pendant une longue période.

Tip

Imaginez que vous souhaitiez créer un agent d'IA capable de faire plus que simplement répondre à des questions simples : il doit gérer des tâches complexes, mémoriser des interactions passées et peut-être même utiliser d'autres outils ou API. C'est là qu'intervient Julep. Lisez Comprendre les tâches pour en savoir plus.

Principales caractéristiques

🧠 Agents IA persistants : mémorisent le contexte et les informations au cours d'interactions à long terme.
💾 Sessions avec état : gardez une trace des interactions passées pour des réponses personnalisées.
🔄 Tâches en plusieurs étapes : créez des processus complexes en plusieurs étapes avec des boucles et une prise de décision.
⏳ Gestion des tâches : gérez les tâches de longue durée qui peuvent s'exécuter indéfiniment.
🛠️ Outils intégrés : utilisez des outils intégrés et des API externes dans vos tâches.
🔧 Auto-réparation : Julep réessaiera automatiquement les étapes ayant échoué, renverra les messages et assurera généralement le bon déroulement de vos tâches.
📚 RAG : Utilisez le magasin de documents de Julep pour créer un système permettant de récupérer et d'utiliser vos propres données.

Tip

Julep est idéal pour les applications qui nécessitent des cas d’utilisation de l’IA au-delà des simples modèles de réponse rapide.

Exemple rapide

Imaginez un agent d’IA de recherche capable d’effectuer les opérations suivantes :

Prenez un sujet,
Proposez 100 requêtes de recherche pour ce sujet,
Effectuez ces recherches Web en parallèle,
Résumez les résultats,
Envoyez le résumé à Discord.

[!REMARQUE] Dans Julep, ce serait une tâche unique sous80 lignes de codeet courirentièrement gérétout seul. Toutes les étapes sont exécutées sur les propres serveurs de Julep et vous n'avez pas besoin de lever le petit doigt.

Voici un exemple fonctionnel :

name: Research Agent

# Optional: Define the input schema for the task
input_schema:
  type: object
  properties:
    topic:
      type: string
      description: The main topic to research

# Define the tools that the agent can use
tools:
  - name: web_search
    type: integration
    integration:
      provider: brave
      setup:
        api_key: BSAqES7dj9d... # dummy key

  - name: discord_webhook
    type: api_call
    api_call:
      url: https://eobuxj02se0n.m.pipedream.net # dummy requestbin
      method: POST
      headers:
        Content-Type: application/json

# Special variables:
# - inputs: for accessing the input to the task
# - outputs: for accessing the output of previous steps
# - _: for accessing the output of the previous step

# Define the main workflow
main:
  - prompt:
      - role: system
        content: >-
          You are a research assistant.
          Generate 100 diverse search queries related to the topic:
          {{inputs[0].topic}}

          Write one query per line.
    unwrap: true

  # Evaluate the search queries using a simple python expression
  - evaluate:
      search_queries: "_.split('\n')"

  # Run the web search in parallel for each query
  - over: "_.search_queries"
    map:
      tool: web_search
      arguments:
        query: "_"
    parallelism: 10

  # Collect the results from the web search
  - evaluate:
      results: "'\n'.join([item.result for item in _])"

  # Summarize the results
  - prompt:
      - role: system
        content: >
          You are a research summarizer. Create a comprehensive summary of the following research results on the topic {{inputs[0].topic}}.
          The summary should be well-structured, informative, and highlight key findings and insights:
          {{_.results}}
    unwrap: true
    settings:
      model: gpt-4o-mini

  # Send the summary to Discord
  - tool: discord_webhook
    arguments:
      content: |-
        f'''
        **Research Summary for {inputs[0].topic}**

        {_}
        '''

Dans cet exemple, Julep gérera automatiquement les exécutions parallèles, réessayera les étapes ayant échoué, renverra les requêtes API et maintiendra les tâches en cours d'exécution de manière fiable jusqu'à leur achèvement.

Cela s'exécute en moins de 30 secondes et renvoie le résultat suivant :

Résumé de la recherche sur l'IA (Cliquez pour agrandir)

Résumé de la recherche sur l'IA

Résumé des résultats de recherche sur l'intelligence artificielle (IA)

Présentation

Le domaine de l’intelligence artificielle (IA) a connu des avancées significatives ces dernières années, marquées par le développement de méthodes et de technologies permettant aux machines de percevoir leur environnement, d’apprendre à partir de données et de prendre des décisions. L’objectif principal de ce résumé est de présenter les enseignements tirés de divers résultats de recherche liés à l’IA.

Principales conclusions

Définition et portée de l’IA :

L'IA est définie comme une branche de l'informatique axée sur la création de systèmes capables d'effectuer des tâches nécessitant une intelligence humaine, notamment l'apprentissage, le raisonnement et la résolution de problèmes (Wikipedia).

Il englobe divers sous-domaines, notamment l’apprentissage automatique, le traitement du langage naturel, la robotique et la vision par ordinateur.

Impact et applications :

Les technologies d'IA sont intégrées dans de nombreux secteurs, améliorant l'efficacité et la productivité. Les applications vont des véhicules autonomes et des diagnostics de santé à l'automatisation du service client et aux prévisions financières (OpenAI).

L'engagement de Google à rendre l'IA bénéfique pour tous met en évidence son potentiel à améliorer considérablement la vie quotidienne en améliorant l'expérience utilisateur sur diverses plateformes (Google AI).

Considérations éthiques :

Un débat est en cours sur les implications éthiques de l'IA, notamment sur les préoccupations relatives à la confidentialité, aux préjugés et à la responsabilité dans les processus de prise de décision. La nécessité d'un cadre garantissant l'utilisation sûre et responsable des technologies de l'IA est soulignée (OpenAI).

Mécanismes d’apprentissage :

Les systèmes d'IA utilisent différents mécanismes d'apprentissage, tels que l'apprentissage supervisé, l'apprentissage non supervisé et l'apprentissage par renforcement. Ces méthodes permettent à l'IA d'améliorer ses performances au fil du temps en apprenant des expériences et des données passées (Wikipedia).

La distinction entre l’apprentissage supervisé et non supervisé est essentielle ; l’apprentissage supervisé s’appuie sur des données étiquetées, tandis que l’apprentissage non supervisé identifie des modèles sans étiquettes prédéfinies (non supervisé).

Orientations futures:

Les futurs développements de l’IA devraient se concentrer sur l’amélioration de l’interprétabilité et de la transparence des systèmes d’IA, garantissant qu’ils peuvent fournir des décisions et des actions justifiables (OpenAI).

On observe également une volonté de rendre les systèmes d’IA plus accessibles et plus conviviaux, encourageant une adoption plus large dans différents groupes démographiques et secteurs (Google AI).

Conclusion

L’IA représente une force de transformation dans de nombreux domaines, promettant de remodeler les industries et d’améliorer la qualité de vie. Cependant, à mesure que ses capacités se développent, il est essentiel de tenir compte des implications éthiques et sociétales qui en découlent. La poursuite des recherches et de la collaboration entre les technologues, les éthiciens et les décideurs politiques sera essentielle pour s’orienter dans le futur paysage de l’IA.

Installation

Pour commencer à utiliser Julep, installez-le en utilisant npm ou pip :

Node.js:

npm install @julep/sdk

# or

bun add @julep/sdk

Python:

pip install julep

[!REMARQUE] Obtenez votre clé API ici.

Pendant que nous sommes en version bêta, vous pouvez également nous contacter sur Discord pour obtenir la levée des limites de débit sur votre clé API.

Tip

💻 Êtes-vous du genre à vouloir montrer le code !™ ? Nous avons créé une multitude de livres de recettes pour vous aider à démarrer. Consultez les livres de recettes pour parcourir les exemples.

💡 Il existe également de nombreuses idées que vous pouvez développer en plus de Julep. Consultez la liste d'idées pour vous inspirer.

Démarrage rapide de Python 🐍

### Step 0: Setup

import time
import yaml
from julep import Julep # or AsyncJulep

client = Julep(api_key="your_julep_api_key")

### Step 1: Create an Agent

agent = client.agents.create(
    name="Storytelling Agent",
    model="claude-3.5-sonnet",
    about="You are a creative storyteller that crafts engaging stories on a myriad of topics.",
)

### Step 2: Create a Task that generates a story and comic strip

task_yaml = """
name: Storyteller
description: Create a story based on an idea.

tools:
  - name: research_wikipedia
    integration:
      provider: wikipedia
      method: search

main:
  # Step 1: Generate plot idea
  - prompt:
      - role: system
        content: You are {{agent.name}}. {{agent.about}}
      - role: user
        content: >
          Based on the idea '{{_.idea}}', generate a list of 5 plot ideas. Go crazy and be as creative as possible. Return your output as a list of long strings inside ```balises yaml à la fin de votre réponse.
déballer : vrai

- évaluer:
plot_ideas : load_yaml(_.split('```yaml')[1].split('```')[0].strip())

# Étape 2 : Extraire les domaines de recherche des idées de l'intrigue
- rapide:
- rôle : système
contenu : Vous êtes {{agent.name}}. {{agent.about}}
- rôle : utilisateur
contenu : >
Voici quelques idées d’intrigue pour une histoire :
{% pour l'idée dans _.plot_ideas %}
- {{idée}}
{% fin de %}

Pour développer l’histoire, nous devons rechercher les idées d’intrigue.
Sur quoi devrions-nous faire des recherches ? Notez les requêtes de recherche Wikipédia pour les idées d'intrigue que vous trouvez intéressantes.
Renvoyez votre sortie sous forme de liste yaml à l'intérieur```yaml tags at the end of your response.
    unwrap: true
    settings:
      model: gpt-4o-mini
      temperature: 0.7

  - evaluate:
      research_queries: load_yaml(_.split('```yaml')[1].split('```')[0].strip())

  # Step 3: Research each plot idea
  - foreach:
      in: _.research_queries
      do:
        tool: research_wikipedia
        arguments:
          query: _

  - evaluate:
      wikipedia_results: 'NEWLINE.join([f"- {doc.metadata.title}: {doc.metadata.summary}" for item in _ for doc in item.documents])'

  # Step 4: Think and deliberate
  - prompt:
      - role: system
        content: You are {{agent.name}}. {{agent.about}}
      - role: user
        content: |-
          Before we write the story, let's think and deliberate. Here are some plot ideas:
          {% for idea in outputs[1].plot_ideas %}
          - {{idea}}
          {% endfor %}

          Here are the results from researching the plot ideas on Wikipedia:
          {{_.wikipedia_results}}

          Think about the plot ideas critically. Combine the plot ideas with the results from Wikipedia to create a detailed plot for a story.
          Write down all your notes and thoughts.
          Then finally write the plot as a yaml object inside ```balises yaml à la fin de votre réponse. L'objet yaml doit avoir la structure suivante :

          ```yaml
          title: "<string>"
          characters:
          - name: "<string>"
            about: "<string>"
          synopsis: "<string>"
          scenes:
          - title: "<string>"
            description: "<string>"
            characters:
            - name: "<string>"
              role: "<string>"
            plotlines:
            - "<string>"```

Assurez-vous que le fichier YAML est valide et que les caractères et les scènes ne sont pas vides. Faites également attention aux points-virgules et autres problèmes liés à l'écriture du fichier YAML.
déballer : vrai

- évaluer:
intrigue : « load_yaml(_.split('```yaml')[1].split('```')[0].strip())"
"""

tâche = client.tasks.create(
agent_id=agent.id,
**yaml.safe_load(tâche_yaml)
)

### Étape 3 : Exécuter la tâche

exécution = client.executions.create(
task_id=task.id,
input={"idea": "Un chat qui apprend à voler"}
)

# 🎉 Regardez l'histoire et les panneaux de bande dessinée se générer
while (result := client.executions.get(execution.id)).status n'est pas dans ['réussi', 'échec'] :
print(résultat.statut, résultat.sortie)
heure.sommeil(1)

# 📦 Une fois l'exécution terminée, récupérez les résultats
si result.status == "réussi" :
imprimer(résultat.sortie)
autre:
déclencher une exception (résultat.erreur)

You can find the full python example here.

|

Node.js Quick Start 🟩

// Étape 0 : Configuration
const dotenv = require("dotenv");
const { Julep } = require("@julep/sdk");
const yaml = require("yaml");

dotenv.config();

const client = nouveau Julep({
Clé API : processus.env.JULEP_API_KEY,
environnement : process.env.JULEP_ENVIRONMENT || "production",
});

/* Étape 1 : Créer un agent */

fonction asynchrone createAgent() {
agent constant = attendez que le client.agents.create({
nom : « Agent de narration »,
modèle : "claude-3.5-sonnet",
à propos de:
« Vous êtes un conteur créatif qui crée des histoires captivantes sur une myriade de sujets. »,
  });
agent de retour;
}

/* Étape 2 : Créer une tâche qui génère une histoire et une bande dessinée */

const tâcheYaml = `
nom : Conteur
description : Créez une histoire basée sur une idée.

outils:
- nom : research_wikipedia
intégration:
fournisseur : wikipedia
méthode : recherche

principal:
# Étape 1 : Générer une idée d'intrigue
- rapide:
- rôle : système
contenu : Vous êtes {{agent.name}}. {{agent.about}}
- rôle : utilisateur
contenu : >
En vous basant sur l'idée « {{_.idea}} », générez une liste de 5 idées d'intrigue. Laissez libre cours à votre créativité. Renvoyez votre résultat sous forme de liste de longues chaînes à l'intérieur des balises \`\`\`yaml à la fin de votre réponse.
déballer : vrai

- évaluer:
plot_ideas: load_yaml(_.split('\`\`\`yaml')[1].split('\`\`\`')[0].strip())

# Étape 2 : Extraire les domaines de recherche des idées de l'intrigue
- rapide:
- rôle : système
contenu : Vous êtes {{agent.name}}. {{agent.about}}
- rôle : utilisateur
contenu : >
Voici quelques idées d’intrigue pour une histoire :
{% pour l'idée dans _.plot_ideas %}
- {{idée}}
{% fin de %}

Pour développer l’histoire, nous devons rechercher les idées d’intrigue.
Sur quoi devrions-nous faire des recherches ? Notez les requêtes de recherche Wikipédia pour les idées d'intrigue que vous trouvez intéressantes.
Renvoyez votre sortie sous forme de liste yaml à l'intérieur des balises \`\`\`yaml à la fin de votre réponse.
déballer : vrai
paramètres:
modèle: gpt-4o-mini
température: 0,7

- évaluer:
requêtes de recherche : load_yaml(_.split('\`\`\`yaml')[1].split('\`\`\`')[0].strip())

# Étape 3 : Recherchez chaque idée d'intrigue
- pour chaque :
dans : _.research_queries
faire:
outil : research_wikipedia
Arguments:
requête: _

- évaluer:
wikipedia_results: 'NEWLINE.join([f"- {doc.metadata.title}: {doc.metadata.summary}" pour l'élément dans _ pour le document dans l'élément.documents])'

# Étape 4 : Réfléchir et délibérer
- rapide:
- rôle : système
contenu : Vous êtes {{agent.name}}. {{agent.about}}
- rôle : utilisateur
contenu: |-
Avant d'écrire l'histoire, réfléchissons et délibérons. Voici quelques idées d'intrigue :
{% pour l'idée dans les sorties[1].plot_ideas %}
- {{idée}}
{% fin de %}

Voici les résultats de la recherche d'idées d'intrigue sur Wikipédia :
{{_.wikipedia_results}}

Réfléchissez aux idées de l'intrigue de manière critique. Combinez les idées de l'intrigue avec les résultats de Wikipédia pour créer une intrigue détaillée pour une histoire.
Écrivez toutes vos notes et vos pensées.
Ensuite, écrivez enfin le tracé sous forme d'objet yaml à l'intérieur des balises \`\`\`yaml à la fin de votre réponse. L'objet yaml doit avoir la structure suivante :

\`\`\`yaml
titre: "<string>"
personnages:
- nom: "<string>"
à propos de: "<string>"
résumé: "<string>"
scènes:
- titre: "<string>"
description: "<string>"
personnages:
- nom: "<string>"
rôle: "<string>"
intrigues:
            - "<string>"\`\`\`

Assurez-vous que le fichier YAML est valide et que les caractères et les scènes ne sont pas vides. Faites également attention aux points-virgules et autres problèmes liés à l'écriture du fichier YAML.
déballer : vrai

- évaluer:
tracé : « load_yaml(_.split('\`\`\`yaml')[1].split('\`\`\`')[0].strip()) »
`;

fonction asynchrone createTask(agentId) {
const tâche = wait client.tasks.create(agentId, yaml.parse(taskYaml));
tâche de retour;
}

/* Étape 3 : Exécuter la tâche */

fonction asynchrone executeTask(taskId) {
const exécution = attendre client.executions.create(taskId, {
entrée : { idée : "Un chat qui apprend à voler" },
  });

// 🎉 Regardez comment l'histoire et les panneaux de bande dessinée sont générés
tandis que (vrai) {
const résultat = wait client.executions.get(execution.id);
console.log(résultat.status, résultat.output);

si (résultat.status === "réussi" || résultat.status === "échec") {
// 📦 Une fois l'exécution terminée, récupérez les résultats
si (résultat.status === "réussi") {
console.log(résultat.sortie);
} autre {
lancer une nouvelle erreur (résultat.erreur);
      }
casser;
    }

attendre une nouvelle promesse((résolution) => setTimeout(résolution, 1000));
  }
}

// Fonction principale pour exécuter l'exemple
fonction asynchrone main() {
essayer {
agent constant = wait createAgent();
const tâche = wait createTask(agent.id);
attendre executeTask(task.id);
} catch (erreur) {
console.error("Une erreur s'est produite :", error);
  }
}

principal()
.then(() => console.log("Terminé"))
.catch(console.erreur);

You can find the full Node.js example here.

|

Components

Julep is made up of the following components:

Julep Platform: The Julep platform is a cloud service that runs your workflows. It includes a language for describing workflows, a server for running those workflows, and an SDK for interacting with the platform.
Julep SDKs: Julep SDKs are a set of libraries for building workflows. There are SDKs for Python and JavaScript, with more on the way.
Julep API: The Julep API is a RESTful API that you can use to interact with the Julep platform.

Mental Model

Think of Julep as a platform that combines both client-side and server-side components to help you build advanced AI agents. Here's how to visualize it:

Your Application Code:
- You can use the Julep SDK in your application to define agents, tasks, and workflows.
- The SDK provides functions and classes that make it easy to set up and manage these components.
Julep Backend Service:
- The SDK communicates with the Julep backend over the network.
- The backend handles execution of tasks, maintains session state, stores documents, and orchestrates workflows.
Integration with Tools and APIs:
- Within your workflows, you can integrate external tools and services.
- The backend facilitates these integrations, so your agents can, for example, perform web searches, access databases, or call third-party APIs.

Concepts

Julep is built on several key technical components that work together to create powerful AI workflows:

graphique TD
Utilisateur[Utilisateur] ==> Session[Session]
Session --> Agent[Agent]
Agent --> Tâches[Tâches]
Agent --> LLM [Modèle de langage étendu]
Tâches --> Outils[Outils]
Agent --> Documents[Documents]
Documents --> VectorDB[Base de données vectorielles]
Tâches --> Exécutions[Exécutions]

client classDef fill:#9ff,trait:#333,largeur-trait:1px;
classe Utilisateur client ;

classDef core fill:#f9f,trait:#333,largeur-trait:2px;
classe Agent,Tâches,Session core;

Agents: AI-powered entities backed by large language models (LLMs) that execute tasks and interact with users.
Users: Entities that interact with agents through sessions.
Sessions: Stateful interactions between agents and users, maintaining context across multiple exchanges.
Tasks: Multi-step, programmatic workflows that agents can execute, including various types of steps like prompts, tool calls, and conditional logic.
Tools: Integrations that extend an agent's capabilities, including user-defined functions, system tools, or third-party API integrations.
Documents: Text or data objects associated with agents or users, vectorized and stored for semantic search and retrieval.
Executions: Instances of tasks that have been initiated with specific inputs, with their own lifecycle and state machine.

|

Understanding Tasks

Tasks are the core of Julep's workflow system. They allow you to define complex, multi-step AI workflows that your agents can execute. Here's a brief overview of task components:

Name, Description and Input Schema: Each task has a unique name and description for easy identification. An input schema (optional) that is used to validate the input to the task.
Main Steps: The core of a task, defining the sequence of actions to be performed. Each step can be a prompt, tool call, evaluate, wait_for_input, log, get, set, foreach, map_reduce, if-else, switch, sleep, or return. (See Types of Workflow Steps for more details)
Tools: Optional integrations that extend the capabilities of your agent during task execution.

Lifecycle of a Task

You create a task using the Julep SDK and specify the main steps that the agent will execute. When you execute a task, the following lifecycle happens:

Diagramme de séquence
participant D comme votre code
participant C en tant que client Julep
participant S en tant que serveur Julep

D->>C : Créer une tâche
C->>S : Soumettre l'exécution
Remarque sur S : Exécuter la tâche
Remarque sur S : Gérer l'état
S-->>C : Événements d'exécution
C-->>D : Mises à jour de la progression
S->>C : Fin de l'exécution
C->>D : Résultat final

Types of Workflow Steps

Tasks in Julep can include various types of steps, allowing you to create complex and powerful workflows. Here's an overview of the available step types:

Common Steps

Name	About	Syntax
Prompt	Send a message to the AI model and receive a response Note: The prompt step uses Jinja templates and you can access context variables in them.	- invite : « Analyser les données suivantes : {{agent.name}} » # <-- ceci est un modèle jinja - rapide: - rôle : système contenu : « Vous êtes {{agent.name}}. {{agent.about}} » - rôle : utilisateur contenu : « Analysez les données suivantes : {{_.data}} »
Tool Call	Execute an integrated tool or API that you have previously declared in the task. Note: The tool call step uses Python expressions inside the arguments.	- outil : recherche_sur_le_web Arguments: requête : « Derniers développements de l'IA » # <-- il s'agit d'une expression Python (remarquez les guillemets) num_results: len(_.topics) # <-- expression python pour accéder à la longueur d'une liste
Evaluate	Perform calculations or manipulate data Note: The evaluate step uses Python expressions.	- évaluer: average_score : somme(scores) / len(scores)
Wait for Input	Pause workflow until input is received. It accepts an `info` field that can be used by your application to collect input from the user. Note: The wait_for_input step is useful when you want to pause the workflow and wait for user input e.g. to collect a response to a prompt.	- attendre_la_saisie : info: message : « Veuillez fournir des informations supplémentaires sur {_.required_info}. » # <-- expression Python pour accéder à la variable de contexte
Log	Log a specified value or message. Note: The log step uses Jinja templates and you can access context variables in them.	- log : « Traitement terminé pour l'élément {{_.item_id}} » # <-- modèle jinja pour accéder à la variable de contexte

Key-Value Steps

Name	About	Syntax
Get	Retrieve a value from the execution's key-value store.	- obtenir : préférences_utilisateur
Set	Assign a value to a key in the execution's key-value store. Note: The set step uses Python expressions.	- ensemble: préférence_utilisateur : '"dark_mode"' # <-- expression python

Iteration Steps

Name

About

Syntax

Foreach

Iterate over a collection and perform steps for each item

- pour chaque :
dans : _.data_list # <-- expression python pour accéder à la variable de contexte
faire:
- log : « Traitement de l'élément {{_.item}} » # <-- modèle jinja pour accéder à la variable de contexte

Map-Reduce

Map over a collection and reduce the results

- map_reduce:
over: _.numbers # <-- expression python pour accéder à la variable de contexte
carte:
- évaluer:
au carré : "_ ** 2"
réduire : résultats + [_] # <-- (facultatif) expression Python pour réduire les résultats. Il s'agit de la valeur par défaut si elle est omise.

- map_reduce:
plus de: _.topics
carte:
- invite : Rédigez un essai sur {{_}}
parallélisme : 10

Parallel

Run multiple steps in parallel

- parallèle:
- outil : recherche_sur_le_web
Arguments:
requête : « Actualités sur l'IA »
- outil : weather_check
Arguments:
Lieu : « New York »

Conditional Steps

Name

About

Syntax

If-Else

Conditional execution of steps

- si : _.score > 0.8 # <-- expression python
alors:
- log : score élevé atteint
autre:
- erreur : le score doit être amélioré

Switch

Execute steps based on multiple conditions

- changer:
- cas : _.category == 'A'
alors:
- log : « Traitement de catégorie A »
- cas : _.category == 'B'
alors:
- log : « Traitement de catégorie B »
- case: _ # Cas par défaut
alors:
- erreur : catégorie inconnue

Other Control Flow

Name	About	Syntax
Sleep	Pause the workflow for a specified duration	- dormir: secondes: 30 # minutes: 1 # heures: 1 # jours: 1
Return	Return a value from the workflow Note: The return step uses Python expressions.	- retour: résultat : " Tâche terminée avec succès " # <-- expression python heure : datetime.now().isoformat() # <-- expression python
Yield	Run a subworkflow and await its completion	- rendement: flux de travail : données_de_processus Arguments: données_d'entrée : _. données_raw # <-- expression python
Error	Handle errors by specifying an error message	- erreur : « Entrée non valide fournie » # <-- Chaînes uniquement

Each step type serves a specific purpose in building sophisticated AI workflows. This categorization helps in understanding the various control flows and operations available in Julep tasks.

|

Tool Types

Agents can be given access to a number of "tools" -- any programmatic interface that a foundation model can "call" with a set of inputs to achieve a goal. For example, it might use a web_search(query) tool to search the Internet for some information.

Unlike agent frameworks, julep is a backend that manages agent execution. Clients can interact with agents using our SDKs. julep takes care of executing tasks and running integrations.

Tools in julep can be one of:

User-defined functions: These are function signatures that you can give the model to choose from, similar to how [openai]'s function-calling works. They need to be handled by the client. The workflow will pause until the client calls the function and gives the results back to julep.
system tools: Built-in tools that can be used to call the julep APIs themselves, like triggering a task execution, appending to a metadata field, etc.
integrations: Built-in third party tools that can be used to extend the capabilities of your agents.
api_calls: Direct api calls during workflow executions as tool calls.

User-defined `functions`

These are function signatures that you can give the model to choose from, similar to how [openai]'s function-calling works. An example:

nom : Exemple de tâche d'outil système
description : Lister les agents à l'aide d'un appel système

outils:
- nom : send_notification
description : Envoyer une notification à l'utilisateur
type : fonction
fonction:
paramètres:
type: objet
propriétés:
texte:
type : chaîne
description : Contenu de la notification

principal:
- outil : send_notification
Arguments:
contenu : '"salut"' # <-- expression python

Whenever julep encounters a user-defined function, it pauses, giving control back to the client and waits for the client to run the function call and give the results back to julep.

[!TIP] > Example cookbook: cookbooks/13-Error_Handling_and_Recovery.py

`system` tools

Built-in tools that can be used to call the julep APIs themselves, like triggering a task execution, appending to a metadata field, etc.

system tools are built into the backend. They get executed automatically when needed. They do not require any action from the client-side.

For example,

nom : Exemple de tâche d'outil système
description : Lister les agents à l'aide d'un appel système

outils:
- nom : list_agent_docs
description : Liste tous les documents pour l'agent donné
type : système
système:
ressource : agent
sous-ressource : doc
opération : liste

principal:
- outil : list_agents
Arguments:
limite : 10 # <-- expression python

Available `system` resources and operations

agent:
- list: List all agents.
- get: Get a single agent by id.
- create: Create a new agent.
- update: Update an existing agent.
- delete: Delete an existing agent.
user:
- list: List all users.
- get: Get a single user by id.
- create: Create a new user.
- update: Update an existing user.
- delete: Delete an existing user.
session:
- list: List all sessions.
- get: Get a single session by id.
- create: Create a new session.
- update: Update an existing session.
- delete: Delete an existing session.
- chat: Chat with a session.
- history: Get the chat history with a session.
task:
- list: List all tasks.
- get: Get a single task by id.
- create: Create a new task.
- update: Update an existing task.
- delete: Delete an existing task.
doc (subresource for agent and user):
- list: List all documents.
- create: Create a new document.
- delete: Delete an existing document.
- search: Search for documents.

Additional operations available for some resources:

embed: Embed a resource (specific resources not specified in the provided code).
change_status: Change the status of a resource (specific resources not specified in the provided code).
chat: Chat with a resource (specific resources not specified in the provided code).
history: Get the chat history with a resource (specific resources not specified in the provided code).
create_or_update: Create a new resource or update an existing one (specific resources not specified in the provided code).

Note: The availability of these operations may vary depending on the specific resource and implementation details.

[!TIP] > Example cookbook: cookbooks/10-Document_Management_and_Search.py

Built-in `integrations`

Julep comes with a number of built-in integrations (as described in the section below). integration tools are directly executed on the julep backend. Any additional parameters needed by them at runtime can be set in the agent/session/user's metadata fields.

See Integrations for details on the available integrations.

[!TIP] > Example cookbook: cookbooks/01-Website_Crawler_using_Spider.ipynb

Direct `api_calls`

julep can also directly make api calls during workflow executions as tool calls. Same as integrations, additional runtime parameters are loaded from metadata fields.

For example,

nom : Exemple de tâche api_call
outils:
- type : api_call
nom : bonjour
appel_API :
méthode : GET
URL: https://httpbin.org/get

principal:
- outil : bonjour
Arguments:
json:
test: _.input # <-- expression python

|

Integrations

Julep supports various integrations that extend the capabilities of your AI agents. Here's a list of available integrations and their supported arguments:

Brave Search	installation: api_key : chaîne # La clé API pour Brave Search Arguments: requête : chaîne # La requête de recherche pour rechercher avec Brave sortir: résultat : chaîne # Le résultat de la recherche Brave	Example cookbook: cookbooks/03-SmartResearcher_With_WebSearch.ipynb
BrowserBase	installation: api_key : chaîne # La clé API pour BrowserBase project_id : chaîne # L'ID de projet pour BrowserBase session_id : chaîne # (facultatif) L'ID de session pour BrowserBase Arguments: urls : liste[chaîne] # Les URL pour le chargement avec BrowserBase sortir: documents : liste # Les documents chargés à partir des URL
Email	installation: hôte : chaîne # L'hôte du serveur de messagerie port : entier # Le port du serveur de messagerie utilisateur : chaîne # Le nom d'utilisateur du serveur de messagerie mot de passe : chaîne # Le mot de passe du serveur de messagerie Arguments: à : chaîne # L'adresse e-mail à laquelle envoyer l'e-mail de : chaîne # L'adresse e-mail à partir de laquelle envoyer l'e-mail objet : chaîne # L'objet de l'e-mail corps : chaîne # Le corps de l'e-mail sortir: succès : booléen # Indique si l'e-mail a été envoyé avec succès	Example cookbook: cookbooks/00-Devfest-Email-Assistant.ipynb
Spider	installation: spider_api_key : chaîne # La clé API pour Spider Arguments: url : chaîne # L'URL pour laquelle récupérer les données mode : chaîne # Le type de robots d'exploration (par défaut : « scrape ») paramètres : dict # (facultatif) Les paramètres de l'API Spider sortir: documents : liste # Les documents renvoyés par l'araignée	Example cookbook: cookbooks/01-Website_Crawler_using_Spider.ipynb
Weather	installation: openweathermap_api_key : chaîne # La clé API pour OpenWeatherMap Arguments: emplacement : chaîne # L'emplacement pour lequel récupérer les données météorologiques sortir: résultat : chaîne # Les données météorologiques pour l'emplacement spécifié	Example cookbook: cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb
Wikipedia	Arguments: requête : chaîne # La chaîne de requête de recherche load_max_docs : entier # Nombre maximal de documents à charger (par défaut : 2) sortir: documents : liste # Les documents renvoyés par la recherche sur Wikipédia	Example cookbook: cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb

For more details, refer to our Integrations Documentation.

|

Other Features

Julep offers a range of advanced features to enhance your AI workflows:

Adding Tools to Agents

Extend your agent's capabilities by integrating external tools and APIs:

client.agents.outils.créer(
agent_id=agent.id,
nom="recherche_sur_le_web",
description="Rechercher des informations sur le Web.",
intégration={
"fournisseur": "courageux",
"méthode": "recherche",
"setup": {"api_key": "votre_brave_api_key"},
    },
)

Managing Sessions and Users

Julep provides robust session management for persistent interactions:

session = client.sessions.create(
agent_id=agent.id,
user_id=utilisateur.id,
context_overflow="adaptatif"
)

# Poursuivre la conversation dans la même session
réponse = client.sessions.chat(
session_id=session.id,
messages=[
      {
"rôle": "utilisateur",
« contenu » : « Suivi de la conversation précédente. »
      }
    ]
)

Document Integration and Search

Easily manage and search through documents for your agents:

# Télécharger un document
document = client.agents.docs.create(
titre="Progrès de l'IA",
content="L'IA change le monde...",
métadonnées={"category": "article_de_recherche"}
)

# Rechercher des documents
résultats = client.agents.docs.search(
texte="Progrès de l'IA",
metadata_filter={"category": "article_de_recherche"}
)

|

Référence

Référence du 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, les tâches et les exécutions :

API des agents
API des tâches
API d'exécution

|

Démarrage rapide local

Exigences:

dernier docker compose installé

Mesures:

git clone https://github.com/julep-ai/julep.git
cd julep
docker volume create cozo_backup
docker volume create cozo_data
cp .env.example .env # <-- Modifier ce fichier
docker compose --env-file .env --profile temporal-ui --profile single-tenant --profile self-hosted-db up --build

|

Quelle est la différence entre Julep et LangChain etc ?

Différents cas d'utilisation

Considérez LangChain et Julep comme des outils avec des objectifs différents au sein de la pile de développement de l’IA.

LangChain est idéal pour créer des séquences d'invites et gérer les interactions avec les LLM. Il dispose d'un vaste écosystème avec de nombreuses intégrations prédéfinies, ce qui le rend pratique si vous souhaitez mettre en place quelque chose rapidement. LangChain s'adapte bien aux cas d'utilisation simples qui impliquent une chaîne linéaire d'invites et d'appels d'API.

Julep, en revanche, s'intéresse davantage à la création d'agents d'IA persistants capables de conserver le contexte lors d'interactions à long terme. Il est idéal lorsque vous avez besoin de flux de travail complexes impliquant des tâches en plusieurs étapes, une logique conditionnelle et une intégration avec divers outils ou API directement dans le processus de l'agent. Il est conçu dès le départ pour gérer les sessions persistantes et les flux de travail complexes.

Utilisez Julep si vous imaginez créer un assistant IA complexe qui doit :

Suivez les interactions des utilisateurs sur plusieurs jours ou semaines.
Exécutez des tâches planifiées, comme l'envoi de résumés quotidiens ou la surveillance des sources de données.
Prendre des décisions basées sur des interactions antérieures ou des données stockées.
Interagir avec plusieurs services externes dans le cadre de son flux de travail.

Ensuite, Julep fournit l’infrastructure pour prendre en charge tout cela sans que vous ayez à le construire à partir de zéro.

Facteur de forme différent

Julep est une plateforme qui comprend un langage pour décrire les workflows, un serveur pour exécuter ces workflows et un SDK pour interagir avec la plateforme. Pour créer quelque chose avec Julep, vous écrivez une description du workflow en YAML, puis vous exécutez le workflow dans le cloud.

Julep est conçu pour les flux de travail lourds, en plusieurs étapes et de longue durée, et il n'y a aucune limite à la complexité du flux de travail.

LangChain est une bibliothèque qui inclut quelques outils et un framework pour créer des chaînes linéaires d'invites et d'outils. Pour créer quelque chose avec LangChain, vous écrivez généralement du code Python qui configure et exécute les chaînes de modèles que vous souhaitez utiliser.

LangChain pourrait être suffisant et plus rapide à mettre en œuvre pour les cas d'utilisation simples impliquant une chaîne linéaire d'invites et d'appels d'API.

En résumé

Utilisez LangChain lorsque vous devez gérer les interactions LLM et les séquences d'invite dans un contexte sans état ou à court terme.

Choisissez Julep lorsque vous avez besoin d'un framework robuste pour les agents avec état avec des capacités de workflow avancées, des sessions persistantes et une orchestration de tâches complexes.

|

Files

README-FR.md

Latest commit

History