^{English | 中文翻译 | 日本語翻訳 | French}

Explorer les documents (en cours) Explorer les documents (en cours) · Discorde · 𝕏 · LinkedIn

[!REMARQUE] Obtenez votre clé API ici.

• Appel à contributeurs 🌟
• Présentation
• Caractéristiques principales
• Exemple rapide
• Installation
• Démarrage rapide de Python 🐍
• Démarrage rapide de Node.js 🟩
• Composants
• Modèle mental
• Concepts
• Comprendre les tâches
• Cycle de vie d'une tâche
• Types d'étapes de flux de travail
• Étapes courantes
• Étapes clé-valeur
• Étapes d'itération
• Étapes conditionnelles
• Autre flux de contrôle
• Types d'outils
• Fonctions définies par l'utilisateur
• outils système
• Ressources et opérations « système » disponibles
• Intégrations intégrées
• [Appels directs api_calls](#appels directs-api_calls)
• Intégrations
• Autres fonctionnalités
• Ajout d'outils aux agents
• Gestion des sessions et des utilisateurs
• Intégration et recherche de documents
• 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 ?
  • Différents cas d'utilisation
  • Facteur de forme différent
  • En résumé

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.

1. 🧠 Agents IA persistants : mémorisent le contexte et les informations au cours d'interactions à long terme.
2. 💾 Sessions avec état : gardez une trace des interactions passées pour des réponses personnalisées.
3. 🔄 Tâches en plusieurs étapes : créez des processus complexes en plusieurs étapes avec des boucles et une prise de décision.
4. ⏳ Gestion des tâches : gérez les tâches de longue durée qui peuvent s'exécuter indéfiniment.
5. 🛠️ Outils intégrés : utilisez des outils intégrés et des API externes dans vos tâches.
6. 🔧 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.
7. 📚 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.

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

1. Prenez un sujet,
2. Proposez 30 requêtes de recherche pour ce sujet,
3. Effectuez ces recherches Web en parallèle,
4. Résumez les résultats,
5. 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
    num_questions:
      type: integer
      description: The number of search queries to generate

# 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

# 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 {{inputs[0].num_questions|default(30, true)}} 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(NEWLINE)"

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

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

# 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. 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

- evaluate:
    discord_message: |-
      f'''
      **Research Summary for {inputs[0].topic}**
      {_}
      '''

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

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 :

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.

### 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
    type: integration
    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 bandes dessinées 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.

 | 

// É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.

 | 

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.

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:

1. 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.

2. 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.

3. 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.

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.

 | 

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.

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

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:

- 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}} »

- 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

- évaluer:
average_score : somme(scores) / len(scores)

- attendre_la_saisie :
info:
message : « Veuillez fournir des informations supplémentaires sur {_.required_info}. » # <-- expression Python pour accéder à la variable de contexte

- log : « Traitement terminé pour l'élément {{_.item_id}} » # <-- modèle jinja pour accéder à la variable de contexte

- obtenir : préférences_utilisateur

- ensemble:
préférence_utilisateur : '"dark_mode"' # <-- expression python

- 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:
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

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

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

- 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

- dormir:
secondes: 30
# minutes: 1
# heures: 1
# jours: 1

- retour:
résultat : " Tâche terminée avec succès " # <-- expression python
heure : datetime.now().isoformat() # <-- expression python

- rendement:
flux de travail : données_de_processus
Arguments:
données_d'entrée : _. données_raw # <-- expression python

- 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.

 | 

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:

1. 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.
2. 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.
3. integrations: Built-in third party tools that can be used to extend the capabilities of your agents.
4. api_calls: Direct api calls during workflow executions as tool calls.

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.

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

• 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/06-browser-use.ipynb

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.ipynb

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

 | 

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

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

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

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

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

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é

Arguments:
requête : chaîne # La chaîne de requête de recherche
load_max_docs : entier # (facultatif) Nombre maximal de documents à charger. La valeur par défaut est 2.

sortir:
documents : liste # Les documents renvoyés par la recherche sur Wikipédia

Arguments:
cmd : chaîne # La commande FFmpeg à exécuter
fichier : chaîne # Le fichier codé en base64 à traiter

sortir:
fileoutput : chaîne # Le fichier de sortie de la commande FFmpeg en codage base64
résultat : booléen # Si la commande FFmpeg a été exécutée avec succès
mime_type : chaîne # Le type MIME du fichier de sortie

installation:
llamaparse_api_key: string # La clé API pour Llama Parse
paramètres : dict # (facultatif) Paramètres supplémentaires pour l'intégration de Llama Parse

Arguments:
fichier : chaîne | tableau<string># Le fichier codé en base64 à analyser ou un tableau d'URL http/https à charger.
nom de fichier : chaîne # (facultatif). Le nom de fichier du fichier. La valeur par défaut est un UUID aléatoire. Utilisé uniquement si le fichier est une chaîne codée en base64.
params : dict # (facultatif) Paramètres supplémentaires pour l'intégration de Llama Parse. Remplace les paramètres de configuration.
base64 : booléen # Indique si le fichier d'entrée est encodé en base64. La valeur par défaut est false.

sortir:
documents : liste # Les données analysées du document

méthode : media_upload | media_edit # La méthode à utiliser pour l'intégration Cloudinary

installation:
cloudinary_cloud_name : chaîne # Votre nom de cloud Cloudinary
cloudinary_api_key : chaîne # Votre clé API Cloudinary
cloudinary_api_secret : chaîne # Votre secret d'API Cloudinary
paramètres : dict # (facultatif) Paramètres supplémentaires pour l'intégration Cloudinary

Arguments:
fichier : chaîne # L'URL du téléchargement du fichier. Disponible uniquement pour la méthode media_upload.
upload_params : dict # (facultatif) Paramètres supplémentaires pour le téléchargement. Disponible uniquement pour la méthode media_upload.
public_id : chaîne # (facultatif) L'ID public du fichier. Pour la méthode media_edit, il est OBLIGATOIRE. Pour la méthode media_upload, il est facultatif. La valeur par défaut est un UUID aléatoire.
transformation : list[dict] # Les transformations à appliquer au fichier. Disponible uniquement pour la méthode media_edit.
return_base64 : booléen # Indique si le fichier doit être renvoyé en codage base64. La valeur par défaut est false.

sortir:
url : chaîne # L'URL du fichier téléchargé. Disponible uniquement pour la méthode media_upload.
meta_data : dict # Métadonnées supplémentaires provenant de la réponse de téléchargement. Disponible uniquement pour la méthode media_upload.
public_id : chaîne # L'ID public du fichier téléchargé. Disponible uniquement pour la méthode media_upload.
turned_url : chaîne # (facultatif) L'URL transformée. Disponible uniquement pour la méthode media_edit.
base64 : chaîne # (Facultatif) Le fichier codé en base64 si return_base64 est vrai.

For more details, refer to our Integrations Documentation.

 | 

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

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"},
    },
)

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. »
      }
    ]
)

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"}
)

 | 

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

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

 | 

Exigences:

• dernier docker compose installé

Mesures:

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

 | 

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 de 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.

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.

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.

 |