From f2ffbf5bafc50daab307716605358934df9f3f8b Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sat, 19 Oct 2024 10:05:49 +0530
Subject: [PATCH] Translate README.md (#711)

This PR updates the translated versions of README.md

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 README-CN.md | 1456 ++++++++++++++++++++++++++++-------------------
 README-FR.md | 1487 ++++++++++++++++++++++++++++--------------------
 README-JA.md | 1529 +++++++++++++++++++++++++++++---------------------
 3 files changed, 2644 insertions(+), 1828 deletions(-)

diff --git a/README-CN.md b/README-CN.md
index 1a07ad109..24c488aef 100644
--- a/README-CN.md
+++ b/README-CN.md
@@ -6,7 +6,7 @@
 
 <p align="center">
   <br />
-  <a href="https://docs.julep.ai" rel="dofollow"><strong>探索文档</strong></a>
+  <a href="https://docs.julep.ai" rel="dofollow">探索文档</a>
   ·
   <a href="https://discord.com/invite/JTSBGRZrzj" rel="dofollow">不和谐</a>
   ·
@@ -62,37 +62,39 @@
 
 <!-- START doctoc generated TOC please keep comment here to allow auto update -->
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
-<h3>📖 Table of Contents</h3>
-
-- [主要特点](#%E4%B8%BB%E8%A6%81%E7%89%B9%E7%82%B9)
-- [Python 快速入门🐍](#python-%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8)
-  - [步骤 1：创建代理](#%E6%AD%A5%E9%AA%A4-1%E5%88%9B%E5%BB%BA%E4%BB%A3%E7%90%86)
-  - [步骤 2：创建一个生成故事和漫画的任务](#%E6%AD%A5%E9%AA%A4-2%E5%88%9B%E5%BB%BA%E4%B8%80%E4%B8%AA%E7%94%9F%E6%88%90%E6%95%85%E4%BA%8B%E5%92%8C%E6%BC%AB%E7%94%BB%E7%9A%84%E4%BB%BB%E5%8A%A1)
-  - [步骤 3：执行任务](#%E6%AD%A5%E9%AA%A4-3%E6%89%A7%E8%A1%8C%E4%BB%BB%E5%8A%A1)
-  - [步骤 4：与代理聊天](#%E6%AD%A5%E9%AA%A4-4%E4%B8%8E%E4%BB%A3%E7%90%86%E8%81%8A%E5%A4%A9)
-- [Node.js 快速入门 🟩](#nodejs-%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8-)
-  - [步骤 1：创建代理](#%E6%AD%A5%E9%AA%A4-1%E5%88%9B%E5%BB%BA%E4%BB%A3%E7%90%86-1)
-  - [步骤 2：创建一个生成故事和漫画的任务](#%E6%AD%A5%E9%AA%A4-2%E5%88%9B%E5%BB%BA%E4%B8%80%E4%B8%AA%E7%94%9F%E6%88%90%E6%95%85%E4%BA%8B%E5%92%8C%E6%BC%AB%E7%94%BB%E7%9A%84%E4%BB%BB%E5%8A%A1-1)
-  - [步骤 3：执行任务](#%E6%AD%A5%E9%AA%A4-3%E6%89%A7%E8%A1%8C%E4%BB%BB%E5%8A%A1-1)
-  - [步骤 4：与代理聊天](#%E6%AD%A5%E9%AA%A4-4%E4%B8%8E%E4%BB%A3%E7%90%86%E8%81%8A%E5%A4%A9-1)
-  - [心智模型](#%E5%BF%83%E6%99%BA%E6%A8%A1%E5%9E%8B)
-- [概念](#%E6%A6%82%E5%BF%B5)
-- [理解任务](#%E7%90%86%E8%A7%A3%E4%BB%BB%E5%8A%A1)
-  - [工作流步骤的类型](#%E5%B7%A5%E4%BD%9C%E6%B5%81%E6%AD%A5%E9%AA%A4%E7%9A%84%E7%B1%BB%E5%9E%8B)
-- [工具类型](#%E5%B7%A5%E5%85%B7%E7%B1%BB%E5%9E%8B)
-  - [用户定义的函数](#%E7%94%A8%E6%88%B7%E5%AE%9A%E4%B9%89%E7%9A%84%E5%87%BD%E6%95%B0)
-  - [`系统` 工具](#%E7%B3%BB%E7%BB%9F-%E5%B7%A5%E5%85%B7)
-  - [内置“集成”](#%E5%86%85%E7%BD%AE%E9%9B%86%E6%88%90)
-  - [直接 `api_calls`](#%E7%9B%B4%E6%8E%A5-api_calls)
-- [集成](#%E9%9B%86%E6%88%90)
-  - [向代理添加工具](#%E5%90%91%E4%BB%A3%E7%90%86%E6%B7%BB%E5%8A%A0%E5%B7%A5%E5%85%B7)
-  - [管理会话和用户](#%E7%AE%A1%E7%90%86%E4%BC%9A%E8%AF%9D%E5%92%8C%E7%94%A8%E6%88%B7)
-  - [文档集成与搜索](#%E6%96%87%E6%A1%A3%E9%9B%86%E6%88%90%E4%B8%8E%E6%90%9C%E7%B4%A2)
-- [本地快速启动](#%E6%9C%AC%E5%9C%B0%E5%BF%AB%E9%80%9F%E5%90%AF%E5%8A%A8)
-- [SDK 参考](#sdk-%E5%8F%82%E8%80%83)
-- [为什么选择 Julep 而不是 LangChain？](#%E4%B8%BA%E4%BB%80%E4%B9%88%E9%80%89%E6%8B%A9-julep-%E8%80%8C%E4%B8%8D%E6%98%AF-langchain)
-  - [不同的用例](#%E4%B8%8D%E5%90%8C%E7%9A%84%E7%94%A8%E4%BE%8B)
-  - [不同的外形尺寸](#%E4%B8%8D%E5%90%8C%E7%9A%84%E5%A4%96%E5%BD%A2%E5%B0%BA%E5%AF%B8)
+<h3>📖 目录</h3>
+
+- [简介](#introduction)
+- [主要特点](#key-features)
+- [快速示例](#quick-example)
+- [安装](#安装)
+- [Python 快速入门 🐍](#python-quick-start-)
+- [Node.js 快速入门🟩](#nodejs-quick-start-)
+- [步骤 1：创建代理](#step-1-create-an-agent)
+- [组件](#components)
+- [心智模型](#mental-model)
+- [概念](#concepts)
+- [理解任务](#understanding-tasks)
+- [任务的生命周期](#lifecycle-of-a-task)
+- [工作流步骤的类型](#types-of-workflow-steps)
+- [工具类型](#tool-types)
+- [用户定义的`函数`](#user-defined-functions)
+- [`系统` 工具](#system-tools)
+- [内置 `integrations`](#built-in-integrations)
+-[直接`api_calls`]（#direct-api_calls）
+- [集成](#integrations)
+- [其他功能](#other-features)
+- [向代理添加工具](#adding-tools-to-agents)
+- [管理会话和用户](#managing-sessions-and-users)
+- [文档集成与搜索](#document-integration-and-search)
+- [参考](#reference)
+- [SDK 参考](#sdk-reference)
+- [API 参考](#api-reference)
+- [本地快速启动](#local-quickstart)
+- [Julep 和 LangChain 等有什么区别？](#julep 和 langchain 等之间有什么区别)
+- [不同用例](#different-use-cases)
+- [不同的外形尺寸](#different-form-factor)
+- [总结](#in-summary)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
@@ -102,40 +104,46 @@ Julep 是一个用于创建 AI 代理的平台，这些代理可以记住过去
 
 Julep 支持创建多步骤任务，包括决策、循环、并行处理以及与众多外部工具和 API 的集成。
 
-虽然许多人工智能应用程序仅限于简单、线性的提示链和 API 调用，并且分支很少，但 Julep 可以处理更复杂的场景。
+尽管许多 AI 应用程序仅限于简单、线性的提示和 API 调用链，并且分支很少，但 Julep 可以处理更复杂的场景，这些场景包括：
 
-它支持：
-
-- 复杂、多步骤的流程
-- 动态决策
-- 并行执行
+- 有多个步骤，
+- 根据模型输出做出决策，
+- 产生并行分支，
+- 使用多种工具，并且
+- 长时间运行。
 
 > [!提示]
-> 想象一下，您想要构建一个 AI 代理，它不仅可以回答简单的问题，还可以处理复杂的任务，记住过去的交互，甚至可能使用其他工具或 API。这就是 Julep 的作用所在。
+> 想象一下，您想要构建一个 AI 代理，它不仅可以回答简单的问题，还可以处理复杂的任务、记住过去的交互，甚至可能使用其他工具或 API。这就是 Julep 的作用所在。阅读 [了解任务](#understanding-tasks) 了解更多信息。
 
 ## 主要特点
 
 1. 🧠 **持久 AI 代理**：在长期交互​​中记住上下文和信息。
 2. 💾 **状态会话**：跟踪过去的互动以获得个性化回应。
-3. 🔄 **多步骤任务**：使用循环和决策构建复杂的多步骤流程。
+3. 🔄 **多步骤任务**：通过循环和决策构建复杂的多步骤流程。
 4. ⏳ **任务管理**：处理可以无限期运行的长时间运行的任务。
 5.🛠️**内置工具**：在您的任务中使用内置工具和外部 API。
 6. 🔧 **自我修复**：Julep 将自动重试失败的步骤、重新发送消息，并确保您的任务顺利运行。
 7. 📚 **RAG**：使用 Julep 的文档存储构建一个用于检索和使用您自己的数据的系统。
 
-Julep 非常适合需要超越简单的提示响应模型的 AI 用例的应用程序。
+![功能](https://github.com/user-attachments/assets/4355cbae-fcbd-4510-ac0d-f8f77b73af70)
+
+> [!提示]
+> Julep 非常适合需要超越简单的提示响应模型的 AI 用例的应用程序。
 
 快速示例
 
 想象一下一个可以执行以下操作的研究 AI 代理：
 
-1. 选择一个主题，
+1. **选择一个主题**，
 2. 针对该主题提出 100 个搜索查询，
 3. 同时进行网页搜索，
-4. 总结结果，
-5. 将摘要发送至 Discord
+4. **总结**结果，
+5. 将**摘要发送至 Discord**。
 
-在 Julep 中，这将是一个单一的任务<b>80行代码</b>然后运行<b>完全托管</b>一切都是独立的。所有步骤都在 Julep 自己的服务器上执行，您无需动手。这是一个工作示例：
+> [!注意]
+> 在 Julep 中，这将是一项单独的任务<b>80行代码</b>然后运行<b>完全托管</b>全部独立完成。所有步骤都在 Julep 自己的服务器上执行，您无需动手。
+
+这是一个有效的例子：
 
 ```yaml
 name: Research Agent
@@ -155,12 +163,12 @@ tools:
     integration:
       provider: brave
       setup:
-        api_key: "YOUR_BRAVE_API_KEY"
+        api_key: BSAqES7dj9d...  # dummy key
 
   - name: discord_webhook
     type: api_call
     api_call:
-      url: "YOUR_DISCORD_WEBHOOK_URL"
+      url: https://eobuxj02se0n.m.pipedream.net  # dummy requestbin
       method: POST
       headers:
         Content-Type: application/json
@@ -192,7 +200,7 @@ main:
       tool: web_search
       arguments:
         query: "_"
-    parallelism: 100
+    parallelism: 10
 
   # Collect the results from the web search
   - evaluate:
@@ -206,28 +214,74 @@ main:
           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: >
-        **Research Summary for {{inputs[0].topic}}**
+      content: |-
+        f'''
+        **Research Summary for {inputs[0].topic}**
 
-        {{_}}
+        {_}
+        '''
 ```
 
 在这个例子中，Julep 将自动管理并行执行，重试失败的步骤，重新发送 API 请求，并保持任务可靠运行直到完成。
 
+> 这在 30 秒内运行并返回以下输出：
+
+<details>
+<summary><b>人工智能研究摘要</b> <i>（点击展开）</i></summary>
+
+> **人工智能研究摘要**
+> 
+>###人工智能（AI）研究成果摘要
+> 
+> #### 简介
+> 近年来，人工智能 (AI) 领域取得了重大进展，其特点是方法和技术的发展，使机器能够感知环境、从数据中学习并做出决策。本摘要主要关注从与 AI 相关的各种研究成果中获得的见解。
+> 
+> #### 主要发现
+> 
+> 1. **人工智能的定义和范围**：
+> - 人工智能被定义为计算机科学的一个分支，专注于创建能够执行需要类似人类智能的任务的系统，包括学习、推理和解决问题（维基百科）。
+>——它涵盖了各种子领域，包括机器学习、自然语言处理、机器人和计算机视觉。
+> 
+> 2. **影响与应用**：
+> - AI 技术正在融入众多领域，提高效率和生产力。应用范围从自动驾驶汽车和医疗诊断到客户服务自动化和财务预测（OpenAI）。
+> - 谷歌致力于让人工智能造福每个人，这凸显了其通过增强各个平台的用户体验（谷歌人工智能）显著改善日常生活的潜力。
+> 
+> 3. **道德考虑**：
+> - 关于人工智能的伦理影响的讨论一直在进行中，包括对隐私、偏见和决策过程中的责任的担忧。强调需要一个确保安全和负责任地使用人工智能技术的框架（OpenAI）。
+> 
+> 4. **学习机制**：
+> - AI 系统利用不同的学习机制，例如监督学习、无监督学习和强化学习。这些方法允许 AI 通过从过去的经验和数据中学习来提高性能（维基百科）。
+> - 监督学习和无监督学习之间的区别至关重要；监督学习依赖于标记数据，而无监督学习则识别没有预定义标签的模式（无监督）。
+> 
+> 5. **未来方向**：
+> - 未来人工智能的发展预计将专注于增强人工智能系统的可解释性和透明度，确保它们能够提供合理的决策和行动（OpenAI）。
+> - 人们还在努力使人工智能系统更易于访问和用户友好，鼓励不同人群和行业更广泛地采用它（谷歌人工智能）。
+> 
+> #### 结论
+> 人工智能代表着跨多个领域的变革力量，有望重塑行业并改善生活质量。然而，随着其能力的扩展，解决随之而来的伦理和社会影响至关重要。技术专家、伦理学家和政策制定者之间的持续研究和合作对于驾驭人工智能的未来格局至关重要。
+
+</details>
+
 ＃＃ 安装
 
 要开始使用 Julep，请使用 [npm](https://www.npmjs.com/package/@julep/sdk) 或 [pip](https://pypi.org/project/julep/) 安装它：
 
+**Node.js**：
 ```bash
 npm install @julep/sdk
-```
 
-或者
+# or
 
+bun add @julep/sdk
+```
+
+**Python**：
 ```bash
 pip install julep
 ```
@@ -244,997 +298,1219 @@ pip install julep
 
 ## Python 快速入门🐍
 
-### 步骤 1：创建代理
-
 ```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="gpt-4o",
-    about="You are a creative storytelling agent that can craft engaging stories and generate comic panels based on ideas.",
+    model="claude-3.5-sonnet",
+    about="You are a creative storyteller that crafts engaging stories on a myriad of topics.",
 )
 
-# 🛠️ Add an image generation tool (DALL·E) to the agent
-client.agents.tools.create(
-    agent_id=agent.id,
-    name="image_generator",
-    description="Use this tool to generate images based on descriptions.",
-    integration={
-        "provider": "dalle",
-        "method": "generate_image",
-        "setup": {
-            "api_key": "your_openai_api_key",
-        },
-    },
-)
-```
+### Step 2: Create a Task that generates a story and comic strip
 
-### 步骤 2：创建一个生成故事和漫画的任务
-
-让我们定义一个多步骤任务来创建一个故事并根据输入的想法生成面板漫画：
-
-```python
-# 📋 Task
-# Create a task that takes an idea and creates a story and a 4-panel comic strip
 task_yaml = """
-name: Story and Comic Creator
-description: Create a story based on an idea and generate a 4-panel comic strip illustrating the story.
+name: Storyteller
+description: Create a story based on an idea.
+
+tools:
+  - name: research_wikipedia
+    integration:
+      provider: wikipedia
+      method: search
 
 main:
-  # Step 1: Generate a story and outline into 4 panels
+  # Step 1: Generate plot idea
   - prompt:
       - role: system
         content: You are {{agent.name}}. {{agent.about}}
       - role: user
         content: >
-          Based on the idea '{{_.idea}}', write a short story suitable for a 4-panel comic strip.
-          Provide the story and a numbered list of 4 brief descriptions for each panel illustrating key moments in the story.
+          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 ```yaml 标签位于您的回复末尾。
+展开：true
+
+- 评价：
+情节想法：load_yaml（_.split（'```yaml')[1].split('```')[0].strip())
+
+# 第二步：从情节思路中提取研究领域
+- 迅速的：
+- 角色：系统
+内容：您是 {{agent.name}}。{{agent.about}}
+- 角色：用户
+内容: >
+以下是一些故事情节的想法：
+{% 表示 _.plot_ideas 中的想法 %}
+- {{主意}}
+{% 结束 %}
+
+为了发展故事情节，我们需要研究情节思路。
+我们应该研究什么？写下你认为有趣的情节想法的维基百科搜索查询。
+将输出作为 yaml 列表返回```yaml tags at the end of your response.
     unwrap: true
+    settings:
+      model: gpt-4o-mini
+      temperature: 0.7
 
-  # Step 2: Extract the panel descriptions and story
   - evaluate:
-      story: _.split('1. ')[0].strip()
-      panels: re.findall(r'\\d+\\.\\s*(.*?)(?=\\d+\\.\\s*|$)', _)
+      research_queries: load_yaml(_.split('```yaml')[1].split('```')[0].strip())
 
-  # Step 3: Generate images for each panel using the image generator tool
+  # Step 3: Research each plot idea
   - foreach:
-      in: _.panels
+      in: _.research_queries
       do:
-        tool: image_generator
+        tool: research_wikipedia
         arguments:
-          description: _
+          query: _
+
+  - evaluate:
+      wikipedia_results: 'NEWLINE.join([f"- {doc.metadata.title}: {doc.metadata.summary}" for item in _ for doc in item.documents])'
 
-  # Step 4: Generate a catchy title for the story
+  # Step 4: Think and deliberate
   - prompt:
       - role: system
         content: You are {{agent.name}}. {{agent.about}}
       - role: user
-        content: >
-          Based on the story below, generate a catchy title.
-
-          Story: {{outputs[1].story}}
-    unwrap: true
-
-  # Step 5: Return the story, the generated images, and the title
-  - return:
-      title: outputs[3]
-      story: outputs[1].story
-      comic_panels: "[output.image.url for output in outputs[2]]"
+        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 ```yaml 标签位于响应末尾。yaml 对象应具有以下结构：
+
+          ```yaml
+          title: "<string>"
+          characters:
+          - name: "<string>"
+            about: "<string>"
+          synopsis: "<string>"
+          scenes:
+          - title: "<string>"
+            description: "<string>"
+            characters:
+            - name: "<string>"
+              role: "<string>"
+            plotlines:
+            - "<string>"```
+
+确保 yaml 有效，且角色和场景不为空。还要注意分号和编写 yaml 的其他问题。
+展开：true
+
+- 评价：
+情节：“load_yaml（_.split（'```yaml')[1].split('```')[0].strip())”
 """
 
-task = client.tasks.create(
-    agent_id=agent.id,
-    **yaml.safe_load(task_yaml)
+任务 = 客户端.任务.创建（
+agent_id=代理.id，
+**yaml.safe_load（任务_yaml）
 )
-```
 
 ### 步骤 3：执行任务
 
-```python
-# 🚀 Execute the task with an input idea
-execution = client.executions.create(
-    task_id=task.id,
-    input={"idea": "A cat who learns to fly"}
+执行 = 客户端.执行.创建（
+任务ID=任务ID，
+输入={“idea”：“一只学飞的猫”}
 )
 
-# 🎉 Watch as the story and comic panels are generated
-for transition in client.executions.transitions.stream(execution_id=execution.id):
-    print(transition)
+# 🎉 观看故事和漫画面板的生成
+while (result := client.executions.get(execution.id)).status 不在 ['成功', '失败'] 中：
+打印（结果.状态，结果.输出）
+时间.睡眠(1)
 
-# 📦 Once the execution is finished, retrieve the results
-result = client.executions.get(execution_id=execution.id)
+# 📦执行完成后，检索结果
+如果 result.status ==“成功”：
+打印（结果.输出）
+别的：
+引发异常（结果.错误）
 ```
 
-### 步骤 4：与代理聊天
-
-开始与代理进行交互式聊天会话：
-
-```python
-session = client.sessions.create(agent_id=agent.id)
+You can find the full python example [here](example.py).
 
-# 💬 Send messages to the agent
-while (message := input("Enter a message: ")) != "quit":
-    response = client.sessions.chat(
-        session_id=session.id,
-        message=message,
-    )
-
-    print(response)
-```
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-您可以在[这里](example.py)找到完整的python示例。
+## Node.js Quick Start 🟩
 
-## Node.js 快速入门 🟩
+### Step 1: Create an Agent
 
-### 步骤 1：创建代理
+```JavaScript的
+// 步骤 0：设置
+const dotenv = require（'dotenv'）；
+const { Julep } = require('@julep/sdk');
+const yaml = require（'yaml'）；
 
-```javascript
-import { Julep } from "@julep/sdk";
-import yaml from "js-yaml";
+dotenv.配置（）；
 
-const client = new Julep({ apiKey: "your_julep_api_key" });
+const 客户端 = new Julep（{ apiKey：process.env.JULEP_API_KEY， 环境：process.env.JULEP_ENVIRONMENT || “生产” }）；
 
-async function createAgent() {
-  const agent = await client.agents.create({
-    name: "Storytelling Agent",
-    model: "gpt-4",
-    about:
-      "You are a creative storytelling agent that can craft engaging stories and generate comic panels based on ideas.",
-  });
+/* 步骤 1：创建代理 */
 
-  // 🛠️ Add an image generation tool (DALL·E) to the agent
-  await client.agents.tools.create(agent.id, {
-    name: "image_generator",
-    description: "Use this tool to generate images based on descriptions.",
-    integration: {
-      provider: "dalle",
-      method: "generate_image",
-      setup: {
-        api_key: "your_openai_api_key",
-      },
-    },
+异步函数 createAgent() {
+const 代理 = 等待客户端.代理.创建（{
+名称：“讲故事特工”，
+模型：“claude-3.5-sonnet”，
+关于：“您是一位富有创意的讲故事者，能够就无数主题创作引人入胜的故事。”，
   });
-
-  return agent;
+回報代理；
 }
-```
 
-### 步骤 2：创建一个生成故事和漫画的任务
+/* 步骤 2：创建一个生成故事和漫画的任务 */
 
-```javascript
 const taskYaml = `
-name: Story and Comic Creator
-description: Create a story based on an idea and generate a 4-panel comic strip illustrating the story.
-
-main:
-  # Step 1: Generate a story and outline into 4 panels
-  - prompt:
-      - role: system
-        content: You are {{agent.name}}. {{agent.about}}
-      - role: user
-        content: >
-          Based on the idea '{{_.idea}}', write a short story suitable for a 4-panel comic strip.
-          Provide the story and a numbered list of 4 brief descriptions for each panel illustrating key moments in the story.
-    unwrap: true
-
-  # Step 2: Extract the panel descriptions and story
-  - evaluate:
-      story: _.split('1. ')[0].trim()
-      panels: _.match(/\\d+\\.\\s*(.*?)(?=\\d+\\.\\s*|$)/g)
-
-  # Step 3: Generate images for each panel using the image generator tool
-  - foreach:
-      in: _.panels
-      do:
-        tool: image_generator
-        arguments:
-          description: _
-
-  # Step 4: Generate a catchy title for the story
-  - prompt:
-      - role: system
-        content: You are {{agent.name}}. {{agent.about}}
-      - role: user
-        content: >
-          Based on the story below, generate a catchy title.
-
-          Story: {{outputs[1].story}}
-    unwrap: true
-
-  # Step 5: Return the story, the generated images, and the title
-  - return:
-      title: outputs[3]
-      story: outputs[1].story
-      comic_panels: outputs[2].map(output => output.image.url)
+名称：讲故事的人
+描述：根据一个想法创建一个故事。
+
+工具：
+- 名称：research_wikipedia
+一体化：
+提供者：维基百科
+方法：搜索
+
+主要的：
+# 步骤 1：产生情节想法
+- 迅速的：
+- 角色：系统
+内容：您是 {{agent.name}}。{{agent.about}}
+- 角色：用户
+内容: >
+根据想法“{{_.idea}}”，生成 5 个情节想法的列表。尽情发挥你的想象力和创造力。将输出作为响应末尾的 \`\`\`yaml 标签内的长字符串列表返回。
+展开：true
+
+- 评价：
+plot_ideas：load_yaml（_.split（'\`\`\`yaml'）[1].split（'\`\`\`'）[0].strip（））
+
+# 第二步：从情节思路中提取研究领域
+- 迅速的：
+- 角色：系统
+内容：您是 {{agent.name}}。{{agent.about}}
+- 角色：用户
+内容: >
+以下是一些故事情节的想法：
+{% 表示 _.plot_ideas 中的想法 %}
+- {{主意}}
+{% 结束 %}
+
+为了发展故事情节，我们需要研究情节思路。
+我们应该研究什么？写下你认为有趣的情节想法的维基百科搜索查询。
+将您的输出作为 yaml 列表返回到响应末尾的 \`\`\`yaml 标签内。
+展开：true
+设置：
+型号：gpt-4o-mini
+温度：0.7
+
+- 评价：
+research_queries：load_yaml（_.split（'\`\`\`yaml'）[1].split（'\`\`\`'）[0].strip（））
+
+# 步骤 3：研究每个情节构思
+- foreach：
+在：_.research_queries
+做：
+工具：research_wikipedia
+参数：
+询问： _
+
+- 评价：
+wikipedia_results：'NEWLINE.join（[f“- {doc.metadata.title}：{doc.metadata.summary}”用于 item in _ for doc in item.documents]）'
+
+# 第 4 步：思考和深思
+- 迅速的：
+- 角色：系统
+内容：您是 {{agent.name}}。{{agent.about}}
+- 角色：用户
+内容：|-
+在写故事之前，让我们先思考一下。以下是一些情节构思：
+{% for idea in output[1].plot_ideas %}
+- {{主意}}
+{% 结束 %}
+
+以下是在维基百科上研究情节思路的结果：
+{{_.wikipedia_results}}
+
+认真思考故事情节。将故事情节与维基百科搜索结果相结合，为故事创建详细情节。
+写下你所有的笔记和想法。
+最后，将图表作为 yaml 对象写入响应末尾的 \`\`\`yaml 标签内。yaml 对象应具有以下结构：
+
+\`\`\`yaml
+标题： ”<string>"
+人物：
+- 姓名： ”<string>"
+关于： ”<string>"
+概要：”<string>"
+场景：
+- 标题： ”<string>"
+描述： ”<string>"
+人物：
+- 姓名： ”<string>"
+角色： ”<string>"
+故事情节：
+-”<string>“\`\`\`
+
+确保 yaml 有效，且角色和场景不为空。还要注意分号和编写 yaml 的其他问题。
+展开：true
+
+- 评价：
+情节：“load_yaml（_。split（'\`\`\`yaml'）[1].split（'\`\`\`'）[0].strip（））”
 `;
 
-async function createTask(agent) {
-  const task = await client.tasks.create(agent.id, yaml.load(taskYaml));
-  return task;
-}
-```
-
-### 步骤 3：执行任务
-
-```javascript
-async function executeTask(task) {
-  const execution = await client.executions.create(task.id, {
-    input: { idea: "A cat who learns to fly" },
-  });
-
-  // 🎉 Watch as the story and comic panels are generated
-  for await (const transition of client.executions.transitions.stream(
-    execution.id
-  )) {
-    console.log(transition);
-  }
-
-  // 📦 Once the execution is finished, retrieve the results
-  const result = await client.executions.get(execution.id);
-  return result;
+异步函数 createTask（agentId）{
+const task = await 客户端.tasks.create(
+代理人编号，
+yaml.解析（taskYaml）
+（英文）：
+返回任务；
 }
-```
 
-### 步骤 4：与代理聊天
+/* 步骤 3：执行任务 */
 
-```javascript
-async function chatWithAgent(agent) {
-  const session = await client.sessions.create({ agent_id: agent.id });
-
-  // 💬 Send messages to the agent
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
+异步函数 executeTask (taskId) {
+const 执行 = 等待客户端.执行.创建（taskId，{
+输入：{ 想法：“一只学飞的猫” }
   });
 
-  const chat = async () => {
-    rl.question("Enter a message (or 'quit' to exit): ", async (message) => {
-      if (message.toLowerCase() === "quit") {
-        rl.close();
-        return;
+// 🎉 观看故事和漫画面板的生成
+while (真) {
+const result = 等待客户端.executions.get（execution.id）;
+控制台.log（结果.状态，结果.输出）；
+
+if (result.status === '成功' || result.status === '失败') {
+// 📦执行完成后，检索结果
+如果 (result.status === "成功") {
+控制台.log（结果.输出）；
+} 别的 {
+抛出新的错误（result.error）；
       }
+休息;
+    }
 
-      const response = await client.sessions.chat(session.id, { message });
-      console.log(response);
-      chat();
-    });
-  };
-
-  chat();
+等待新的 Promise（resolve => setTimeout（resolve，1000））；
+  }
 }
 
-// Run the example
-async function runExample() {
-  const agent = await createAgent();
-  const task = await createTask(agent);
-  const result = await executeTask(task);
-  console.log("Task Result:", result);
-  await chatWithAgent(agent);
+// 运行示例的主函数
+异步函数 main() {
+尝试 {
+const agent = await createAgent();
+const task = await createTask(agent.id);
+等待执行任务（任务id）；
+} 捕获 (错误) {
+console.error("发生错误：", error);
+  }
 }
 
-runExample().catch(console.error);
+main().then(() => console.log("完成")).catch(console.error);
 ```
 
-您可以在[这里](example.js)找到完整的 Node.js 示例。
+You can find the full Node.js example [here](example.js).
 
-＃＃ 成分
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-Julep 由以下成分组成：
+## Components
 
-- **Julep 平台**：Julep 平台是运行您的工作流程的云服务。它包括用于描述工作流程的语言、用于运行这些工作流程的服务器以及用于与平台交互的 SDK。
-- **Julep SDKs**：Julep SDKs 是一组用于构建工作流的库。目前有适用于 Python 和 JavaScript 的 SDKs，还有更多 SDKs 正在开发中。
-- **Julep API**：Julep API 是一个 RESTful API，您可以使用它与 Julep 平台进行交互。
+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
 
 <div align="center">
   <img src="https://github.com/user-attachments/assets/38420b5d-9342-4c8d-bae9-b47c28ae45af" height="360" />
 </div>
 
-您可以将 Julep 视为一个结合了客户端和服务器端组件的平台，以帮助您构建高级 AI 代理。以下是它的可视化方法：
+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. **您的申请代码：**
+1. **Your Application Code:**
 
-- 您可以在应用程序中使用 Julep SDK 来定义代理、任务和工作流。
-- SDK 提供的函数和类使得设置和管理这些组件变得容易。
+   - 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 后端服务：**
+2. **Julep Backend Service:**
 
-- SDK 通过网络与 Julep 后端通信。
-- 后端处理任务的执行，维护会话状态，存储文档并协调工作流程。
+   - 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. **与工具和 API 集成：**
-- 在您的工作流程中，您可以集成外部工具和服务。
-- 后端促进这些集成，因此您的代理可以执行网络搜索、访问数据库或调用第三方 API。
+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.
 
-## 概念
+## Concepts
 
-Julep 基于几个关键技术组件构建，这些组件共同协作以创建强大的 AI 工作流程：
+Julep is built on several key technical components that work together to create powerful AI workflows:
 
-```mermaid
-graph TD
-    User[User] ==> Session[Session]
-    Session --> Agent[Agent]
-    Agent --> Tasks[Tasks]
-    Agent --> LLM[Large Language Model]
-    Tasks --> Tools[Tools]
-    Agent --> Documents[Documents]
-    Documents --> VectorDB[Vector Database]
-    Tasks --> Executions[Executions]
+```美人鱼
+图 TD
+用户[用户] ==> 会话[会话]
+会话-->代理[代理]
+代理-->任务[任务]
+代理——> LLM[大型语言模型]
+任务 --> 工具[工具]
+代理人 --> 文件[文件]
+文档 --> VectorDB[矢量数据库]
+任务 --> 执行[执行]
 
-    classDef client fill:#9ff,stroke:#333,stroke-width:1px;
-    class User client;
+classDef 客户端填充：#9ff，描边：#333，描边宽度：1px；
+用户客户端类；
 
-    classDef core fill:#f9f,stroke:#333,stroke-width:2px;
-    class Agent,Tasks,Session core;
+classDef 核心填充：#f9f，描边：#333，描边宽度：2px；
+类代理、任务、会话核心；
 ```
 
-- **代理**：由大型语言模型（LLM）支持的人工智能实体，可执行任务并与用户交互。
-- **用户**：通过会话与代理交互的实体。
-- **会话**：代理和用户之间的状态交互，在多个交换之间维护上下文。
-- **任务**：代理可以执行的多步骤、程序化工作流，包括提示、工具调用和条件逻辑等各种类型的步骤。
-- **工具**：扩展代理功能的集成，包括用户定义的函数、系统工具或第三方 API 集成。
-- **文档**：与代理或用户相关的文本或数据对象，矢量化并存储以用于语义搜索和检索。
-- **执行**：通过特定输入启动的任务实例，具有自己的生命周期和状态机。
+- **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.
+
+
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
+## 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](#types-of-workflow-steps) for more details)
+- **Tools**: Optional integrations that extend the capabilities of your agent during task execution.
 
-有关更详细的解释，请参阅我们的[概念文档]（https://github.com/julep-ai/julep/blob/dev/docs/julep-concepts.md）。
+### 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:
 
-任务是 Julep 工作流系统的核心。它们允许您定义代理可以执行的复杂、多步骤 AI 工作流。以下是任务组件的简要概述：
+```美人鱼
+顺序图
+参与者 D 作为您的代码
+参与者 C 作为 Julep 客户
+参与者 S 担任 Julep 服务器
 
-- **名称和描述**：每个任务都有唯一的名称和描述，以便于识别。
-- **主要步骤**：任务的核心，定义要执行的操作顺序。
-- **工具**：可选集成，可在任务执行期间扩展代理的功能。
+D->>C：创建任务
+C->>S：提交执行
+注意 S：执行任务
+S 注释：管理状态
+S-->>C：执行事件
+C-->>D：进度更新
+S->>C：执行完成
+C->>D：最终结果
+```
 
-### 工作流步骤的类型
+### Types of Workflow Steps
 
-Julep 中的任务可以包含各种类型的步骤，让您可以创建复杂而强大的工作流程。以下是可用步骤类型的概述：
+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
 
 <table>
 <tr>
-<td>姓名</td> <td>关于</td><td>句法</td>
+    <th>Name</th>
+    <th>About</th>
+    <th>Syntax</th>
 </tr>
 <tr>
-<td>迅速的</td>
+<td> <b>Prompt</b> </td>
 <td>
-向 AI 模型发送消息并接收响应
-
+Send a message to the AI model and receive a response
+<br><br><b>Note:</b> The prompt step uses Jinja templates and you can access context variables in them.
 </td>
 
 <td>
 
 ```yaml
-- prompt: "Analyze the following data: {{data}}"
+- prompt: "分析以下数据：{{agent.name}}" # <-- 这是一个 jinja 模板
+```
+
+```yaml
+- 迅速的：
+- 角色：系统
+内容：“您是 {{agent.name}}。 {{agent.about}}”
+- 角色：用户
+内容：“分析以下数据：{{_.data}}”
 ```
 
 </td>
 </tr>
 <tr>
-<td>工具调用</td>
+<td> <b>Tool Call</b> </td>
 <td>
-执行集成工具或 API
+Execute an integrated tool or API that you have previously declared in the task.
+<br><br><b>Note:</b> The tool call step uses Python expressions inside the arguments.
 
 </td>
 
 <td>
 
 ```yaml
-- tool: web_search
-  arguments:
-    query: "Latest AI developments"
+- 工具：web_search
+参数：
+查询：“最新的 AI 发展”#<- 这是一个 Python 表达式（注意引号）
+num_results: len(_.topics) # <-- 用于访问列表长度的 Python 表达式
 ```
 
 </td>
 </tr>
 <tr>
-<td>评价</td>
+<td> <b>Evaluate</b> </td>
 <td>
-执行计算或处理数据
-
+Perform calculations or manipulate data
+<br><br><b>Note:</b> The evaluate step uses Python expressions.
 </td>
 
 <td>
 
 ```yaml
-- evaluate:
-    average_score: "sum(scores) / len(scores)"
+- 评价：
+平均分数：总分（分数）/长度（分数）
 ```
 
 </td>
 </tr>
 <tr>
-<td>等待输入</td>
+<td> <b>Wait for Input</b> </td>
 <td>
-暂停工作流程直到收到输入
+Pause workflow until input is received. It accepts an `info` field that can be used by your application to collect input from the user.
+
+<br><br><b>Note:</b> 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.
 
 </td>
 
 <td>
 
 ```yaml
-- wait_for_input:
-    info:
-      message: "Please provide additional information."
+-等待输入：
+信息：
+消息：'“请提供有关 {_.required_info} 的其他信息。”' # <-- 用于访问上下文变量的 python 表达式
 ```
 
 </td>
 </tr>
 <tr>
-<td>日志</td>
+<td> <b>Log</b> </td>
 <td>
-记录指定的值或消息
+Log a specified value or message.
+
+<br><br><b>Note:</b> The log step uses Jinja templates and you can access context variables in them.
 
 </td>
 
 <td>
 
 ```yaml
-- log: "Processing completed for item {{item_id}}"
+- log：“项目 {{_.item_id}} 的处理已完成”#<-- jinja 模板用于访问上下文变量
 ```
 
 </td>
 </tr>
 </table>
 
-#### 键值步骤
+#### Key-Value Steps
 
 <table>
 <tr>
-<td>姓名</td> <td>关于</td><td>句法</td>
+<th> Name </th> <th> About </th><th>Syntax</th>
 </tr>
 <tr>
-<td>得到</td>
+<td> <b>Get</b> </td>
 <td>
-从键值存储中检索值
+Retrieve a value from the execution's key-value store.
 
 </td>
 
 <td>
 
 ```yaml
-- get: "user_preference"
+- 获取：用户偏好
 ```
 
 </td>
 </tr>
 <tr>
-<td>放</td>
+<td> <b>Set</b> </td>
 <td>
-为键值存储中的键分配值
+Assign a value to a key in the execution's key-value store.
 
+<br><br><b>Note:</b> The set step uses Python expressions.
 </td>
 
 <td>
 
 ```yaml
-- set:
-    user_preference: "dark_mode"
+- 放：
+user_preference: '"dark_mode"' # <-- python 表达式
 ```
 
 </td>
 </tr>
 </table>
 
-#### 迭代步骤
+#### Iteration Steps
 
 <table>
 <tr>
-<td>姓名</td> <td>关于</td><td>句法</td>
+<th> Name </th> <th> About </th><th>Syntax</th>
 </tr>
 <tr>
-<td>Foreach</td>
+<td> <b>Foreach</b> </td>
 <td>
-遍历集合并对每个项目执行步骤
+Iterate over a collection and perform steps for each item
 
 </td>
 
 <td>
 
 ```yaml
-- foreach:
-    in: "data_list"
-    do:
-      - log: "Processing item {{_}}"
+- foreach：
+in: _.data_list # <-- 用于访问上下文变量的 python 表达式
+做：
+- log: "处理项目 {{_.item}}" # <-- jinja 模板访问上下文变量
 ```
 
 </td>
 </tr>
 <tr>
-<td>Map-Reduce</td>
+<td> <b>Map-Reduce</b> </td>
 <td>
-对集合进行映射并减少结果
+Map over a collection and reduce the results
 
 </td>
 
 <td>
 
 ```yaml
-- map_reduce:
-    over: "numbers"
-    map:
-      - evaluate:
-          squared: "_ ** 2"
-    reduce: "sum(results)"
+- 映射_减少：
+over: _.numbers # <-- 用于访问上下文变量的 python 表达式
+地图：
+- 评价：
+平方：“_ ** 2”
+reduce：results + [_] # <--（可选）python 表达式以减少结果。如果省略，则为默认值。
+```
+
+```yaml
+- 映射_减少：
+结束：_.topics
+地图：
+- 提示：写一篇关于{{__}}的文章
+并行度：10
 ```
 
 </td>
 </tr>
 <tr>
-<td>平行线</td>
+<td> <b>Parallel</b> </td>
 <td>
-并行运行多个步骤
+Run multiple steps in parallel
 
 </td>
 
 <td>
 
 ```yaml
-- parallel:
-    - tool: web_search
-      arguments:
-        query: "AI news"
-    - tool: weather_check
-      arguments:
-        location: "New York"
+- 平行线：
+- 工具：web_search
+参数：
+查询：“AI 新闻”
+- 工具：weather_check
+参数：
+地点：“纽约”
 ```
 
 </td>
 </tr>
 </table>
 
-#### 条件步骤
+#### Conditional Steps
 
 <table>
 <tr>
-<td>姓名</td> <td>关于</td><td>句法</td>
+<th> Name </th> <th> About </th><th>Syntax</th>
 </tr>
 <tr>
-<td>如果-否则</td>
+<td> <b>If-Else</b> </td>
 <td>
-有条件地执行步骤
+Conditional execution of steps
 
 </td>
 
 <td>
 
 ```yaml
-- if: "score > 0.8"
-  then:
-    - log: "High score achieved"
-  else:
-    - log: "Score needs improvement"
+- if: _.score > 0.8 # <-- python 表达式
+然后：
+- 日志：取得高分
+别的：
+- 错误：分数需要提高
 ```
 
 </td>
 </tr>
 <tr>
-<td>转变</td>
+<td> <b>Switch</b> </td>
 <td>
-根据多个条件执行步骤
+Execute steps based on multiple conditions
 
 </td>
 
 <td>
 
 ```yaml
-- switch:
-    - case: "category == 'A'"
-      then:
-        - log: "Category A processing"
-    - case: "category == 'B'"
-      then:
-        - log: "Category B processing"
-    - case: "_" # Default case
-      then:
-        - log: "Unknown category"
+- 转变：
+- 案例：_.category =='A'
+然后：
+- 日志：“A 类处理”
+- 案例：_.category =='B'
+然后：
+- 日志：“B类处理”
+- case: _ # 默认情况
+然后：
+- 错误：未知类别
 ```
 
 </td>
 </tr>
 </table>
 
-#### 其他控制流
+#### Other Control Flow
 
 <table>
 <tr>
-<td>姓名</td> <td>关于</td><td>句法</td>
+<th> Name </th> <th> About </th><th>Syntax</th>
 </tr>
 <tr>
-<td>睡觉</td>
+<td> <b>Sleep</b> </td>
 <td>
-暂停工作流一段指定的时间
+Pause the workflow for a specified duration
 
 </td>
 
 <td>
 
 ```yaml
-- sleep:
-    seconds: 30
+- 睡觉：
+秒：30
+# 分钟：1
+#小时数：1
+#天数：1
 ```
 
 </td>
 </tr>
 <tr>
-<td>返回</td>
+<td> <b>Return</b> </td>
 <td>
-从工作流返回值
+Return a value from the workflow
+
+<br><br><b>Note:</b> The return step uses Python expressions.
 
 </td>
 
 <td>
 
 ```yaml
-- return:
-    result: "Task completed successfully"
+- 返回：
+result: '“任务成功完成”' #<-- python 表达式
+时间：datetime.now().isoformat() # <-- python 表达式
 ```
 
 </td>
 </tr>
 <tr>
-<td>屈服</td>
+<td> <b>Yield</b> </td>
 <td>
-运行子工作流并等待其完成
+Run a subworkflow and await its completion
 
 </td>
 
 <td>
 
 ```yaml
-- yield:
-    workflow: "data_processing_subflow"
-    arguments:
-      input_data: "{{raw_data}}"
+- 屈服：
+工作流程：process_data
+参数：
+输入数据：_.raw_data # <-- python 表达式
 ```
 
 </td>
 </tr>
 </tr>
 <tr>
-<td>错误</td>
+<td> <b>Error</b> </td>
 <td>
-通过指定错误消息来处理错误
+Handle errors by specifying an error message
 
 </td>
 
 <td>
 
 ```yaml
-- error: "Invalid input provided"
+- 错误：“提供的输入无效”#<-- 仅限字符串
 ```
 
 </td>
 </tr>
 </table>
 
-每种步骤类型在构建复杂的 AI 工作流中都有特定的用途。此分类有助于理解 Julep 任务中可用的各种控制流程和操作。
-
-## 工具类型
+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.
 
-代理可以访问许多“工具”——基础模型可以使用一组输入“调用”的任何编程接口来实现目标。例如，它可以使用“web_search(query)”工具在互联网上搜索一些信息。
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-与代理框架不同，julep 是管理代理执行的后端。客户端可以使用我们的 SDK 与代理进行交互。julep 负责执行任务和运行集成。
+## Tool Types
 
-julep 中的工具可以是以下之一：
+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.
 
-这些是您可以为模型提供的函数签名，类似于 [openai] 的函数调用工作方式。例如：
+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.
 
-```yaml
-name: Example system tool task
-description: List agents using system call
+### User-defined `functions`
 
-tools:
-  - name: send_notification
-    description: Send a notification to the user
-    type: function
-    function:
-      parameters:
-        type: object
-        properties:
-          text:
-            type: string
-            description: Content of the notification
+These are function signatures that you can give the model to choose from, similar to how [openai]'s function-calling works. An example:
 
-main:
-  - tool: send_notification
-    arguments:
-      content: hi
+```yaml
+名称：示例系统工具任务
+描述：使用系统调用列出代理
+
+工具：
+- 名称：send_notification
+描述：向用户发送通知
+类型：函数
+功能：
+参数：
+类型：对象
+特性：
+文本：
+类型：字符串
+描述：通知内容
+
+主要的：
+- 工具：send_notification
+参数：
+内容：'“hi”'#<--python 表达式
 ```
 
-每当 julep 遇到_用户定义函数_时，它就会暂停，将控制权交还给客户端，并等待客户端运行函数调用并将结果返回给 julep。
+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.
 
-> [!提示]
-> **示例食谱**：[cookbooks/13-Error_Handling_and_Recovery.py](https://github.com/julep-ai/julep/blob/dev/cookbooks/13-Error_Handling_and_Recovery.py)
+> [!TIP]
+> **Example cookbook**: [cookbooks/13-Error_Handling_and_Recovery.py](https://github.com/julep-ai/julep/blob/dev/cookbooks/13-Error_Handling_and_Recovery.py)
 
-### `系统` 工具
+### `system` tools
 
-内置工具可用于调用 julep API 本身，例如触发任务执行、附加到元数据字段等。
-“系统”工具内置于后端。它们会在需要时自动执行。它们不需要客户端的任何操作。
+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.
 
-```yaml
-name: Example system tool task
-description: List agents using system call
+For example,
 
-tools:
-  - name: list_agents
-    description: List all agents
-    type: system
-    system:
-      resource: agent
-      operation: list
-main:
-  - tool: list_agents
-    arguments:
-      limit: 10
+```yaml
+名称：示例系统工具任务
+描述：使用系统调用列出代理
+
+工具：
+- 名称：list_agent_docs
+描述：列出给定代理的所有文档
+类型：系统
+系统：
+资源：代理
+子资源：doc
+操作：列表
+
+主要的：
+- 工具：list_agents
+参数：
+限制：10 #<-- python 表达式
 ```
 
-> [!提示]
-> **示例食谱**：[cookbooks/10-Document_Management_and_Search.py​​](https://github.com/julep-ai/julep/blob/dev/cookbooks/10-Document_Management_and_Search.py​​)
+#### 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.
 
-Julep 带有许多内置集成（如下节所述）。`集成` 工具直接在 julep 后端执行。它们在运行时所需的任何其他参数都可以在代理/会话/用户的 `元数据` 字段中设置。
+- `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.
 
-> [!提示]
-> **示例食谱**：[cookbooks/01-Website_Crawler_using_Spider.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/01-Website_Crawler_using_Spider.ipynb)
+- `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](https://github.com/julep-ai/julep/blob/dev/cookbooks/10-Document_Management_and_Search.py)
 
-julep 后端附带来自以下提供商的集成第三方工具：
+### Built-in `integrations`
 
-- [合成](https://composio.dev)
-- [匿名](https://anon.com)
-- [langchain 工具包](https://python.langchain.com/v0.2/docs/integrations/toolkits/)
+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.
 
-计划支持_Github、Gitlab、Gmail、Jira、MultiOn、Slack_工具包。
+See [Integrations](#integrations) for details on the available integrations.
 
-由于_composio_和_anon_是第三方提供商，因此他们的工具需要设置帐户链接。
+> [!TIP]
+> **Example cookbook**: [cookbooks/01-Website_Crawler_using_Spider.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/01-Website_Crawler_using_Spider.ipynb)
 
-### 直接 `api_calls`
 
-julep 还可以在工作流执行期间直接以工具调用的形式进行 api 调用。与“集成”相同，其他运行时参数从“元数据”字段加载。
+### Direct `api_calls`
 
-例如，
+julep can also directly make api calls during workflow executions as tool calls. Same as `integration`s, additional runtime parameters are loaded from `metadata` fields.
+
+For example,
 
 ```yaml
-name: Example api_call task
-tools:
-  - type: api_call
-    name: hello
-    api_call:
-      method: GET
-      url: https://httpbin.org/get
-main:
-  - tool: hello
-    arguments:
-      params:
-        test: _.input
+名称：示例 api_call 任务
+工具：
+- 类型：api_call
+名字：你好
+API调用：
+方法：GET
+网址：https://httpbin.org/get
+
+主要的：
+- 工具：你好
+参数：
+json：
+测试：_.input#<--python 表达式
 ```
 
-## 集成
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
+## Integrations
 
-Julep 支持各种集成，可以扩展您的 AI 代理的功能。以下是可用集成及其支持的参数的列表：
+Julep supports various integrations that extend the capabilities of your AI agents. Here's a list of available integrations and their supported arguments:
 
 <table>
 
 <tr>
-<td>勇敢搜索</td>
+<td> <b>Brave Search</b> </td>
 <td>
 
 ```yaml
-setup:
-  api_key: string # The API key for Brave Search
+设置：
+api_key: string # Brave Search 的 API 密钥
 
-arguments:
-  query: string # The search query for searching with Brave
+参数：
+query: string # 使用 Brave 搜索的搜索查询
 
-output:
-  result: string # The result of the Brave Search
+输出：
+result: string # Brave Search 的结果
 ```
 
 </td>
 
 <td>
 
-**示例食谱**：[cookbooks/03-SmartResearcher_With_WebSearch.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/03-SmartResearcher_With_WebSearch.ipynb)
+**Example cookbook**: [cookbooks/03-SmartResearcher_With_WebSearch.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/03-SmartResearcher_With_WebSearch.ipynb)
 
 </td>
 </tr>
 <tr>
-<td>浏览器基础</td>
+<td> <b>BrowserBase</b> </td>
 <td>
 
 ```yaml
-setup:
-  api_key: string # The API key for BrowserBase
-  project_id: string # The project ID for BrowserBase
-  session_id: string # (Optional) The session ID for BrowserBase
+设置：
+api_key: string # BrowserBase 的 API 密钥
+project_id: string # BrowserBase 的项目 ID
+session_id: string #（可选）BrowserBase 的会话 ID
 
-arguments:
-  urls: list[string] # The URLs for loading with BrowserBase
+参数：
+urls: list[string] # 使用 BrowserBase 加载的 URL
 
-output:
-  documents: list # The documents loaded from the URLs
+输出：
+documents: list # 从 URL 加载的文档
 ```
 
 </td>
 
 </tr>
 <tr>
-<td>电子邮件</td>
+<td> <b>Email</b> </td>
 <td>
 
 ```yaml
-setup:
-  host: string # The host of the email server
-  port: integer # The port of the email server
-  user: string # The username of the email server
-  password: string # The password of the email server
-
-arguments:
-  to: string # The email address to send the email to
-  from: string # The email address to send the email from
-  subject: string # The subject of the email
-  body: string # The body of the email
-
-output:
-  success: boolean # Whether the email was sent successfully
+设置：
+host: string # 电子邮件服务器的主机
+port: integer # 电子邮件服务器的端口
+用户：string#电子邮件服务器的用户名
+password: string # 邮件服务器的密码
+
+参数：
+to: string # 要发送电子邮件到的电子邮件地址
+from: string # 发送电子邮件的电子邮件地址
+subject: string # 电子邮件的主题
+body: string # 电子邮件正文
+
+输出：
+success: boolean # 邮件是否发送成功
 ```
 
 </td>
 
 <td>
 
-**示例食谱**：[cookbooks/00-Devfest-Email-Assistant.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/00-Devfest-Email-Assistant.ipynb)
+**Example cookbook**: [cookbooks/00-Devfest-Email-Assistant.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/00-Devfest-Email-Assistant.ipynb)
 
 </td>
 </tr>
 <tr>
-<td>蜘蛛</td>
+<td> <b>Spider</b> </td>
 <td>
 
 ```yaml
-setup:
-  spider_api_key: string # The API key for Spider
+设置：
+spider_api_key: string # Spider 的 API 密钥
 
-arguments:
-  url: string # The URL for which to fetch data
-  mode: string # The type of crawlers (default: "scrape")
-  params: dict # (Optional) The parameters for the Spider API
+参数：
+url: string # 获取数据的 URL
+mode: string # 爬虫的类型（默认值：“scrape”）
+params: dict # （可选）Spider API 的参数
 
-output:
-  documents: list # The documents returned from the spider
+输出：
+documents: list # 蜘蛛返回的文档
 ```
 
 </td>
 
 <td>
 
-**示例食谱**：[cookbooks/01-Website_Crawler_using_Spider.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/01-Website_Crawler_using_Spider.ipynb)
+**Example cookbook**: [cookbooks/01-Website_Crawler_using_Spider.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/01-Website_Crawler_using_Spider.ipynb)
 
 </td>
 </tr>
 <tr>
-<td>天气</td>
+<td> <b>Weather</b> </td>
 <td>
 
 ```yaml
-setup:
-  openweathermap_api_key: string # The API key for OpenWeatherMap
+设置：
+openweathermap_api_key: string # OpenWeatherMap 的 API 密钥
 
-arguments:
-  location: string # The location for which to fetch weather data
+参数：
+location: string # 获取天气数据的位置
 
-output:
-  result: string # The weather data for the specified location
+输出：
+result: string # 指定位置的天气数据
 ```
 
 </td>
 
 <td>
 
-**示例食谱**：[cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb)
+**Example cookbook**: [cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb)
 
 </td>
 </tr>
 </tr>
 <tr>
-<td>维基百科</td>
+<td> <b>Wikipedia</b> </td>
 <td>
 
 ```yaml
-arguments:
-  query: string # The search query string
-  load_max_docs: integer # Maximum number of documents to load (default: 2)
+参数：
+query: string # 搜索查询字符串
+load_max_docs：整数#要加载的最大文档数（默认值：2）
 
-output:
-  documents: list # The documents returned from the Wikipedia search
+输出：
+documents: list # 从 Wikipedia 搜索返回的文档
 ```
 
 </td>
 
 <td>
 
-**示例食谱**：[cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb)
+**Example cookbook**: [cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb)
 
 </td>
 </tr>
 </table>
 
-有关更多详细信息，请参阅我们的 [集成文档](https://docs.julep.ai/integrations)。
+For more details, refer to our [Integrations Documentation](#integrations).
 
-其他功能
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-Julep 提供一系列高级功能来增强您的 AI 工作流程：
+## Other Features
 
-### 向代理添加工具
+Julep offers a range of advanced features to enhance your AI workflows:
 
-通过集成外部工具和 API 来扩展代理的功能：
+### Adding Tools to Agents
 
-```python
-client.agents.tools.create(
-    agent_id=agent.id,
-    name="web_search",
-    description="Search the web for information.",
-    integration={
-        "provider": "brave",
-        "method": "search",
-        "setup": {"api_key": "your_brave_api_key"},
-    },
+Extend your agent's capabilities by integrating external tools and APIs:
+
+```Python
+客户端.代理.工具.创建（
+agent_id=代理.id，
+名称="web_search",
+description="在网络上搜索信息。",
+积分={
+“提供者”：“勇敢”，
+“方法”：“搜索”，
+“设置”：{“api_key”：“你的brave_api_key”}，
+}，
 )
 ```
 
-### 管理会话和用户
+### Managing Sessions and Users
 
-Julep 为持久交互提供了强大的会话管理：
+Julep provides robust session management for persistent interactions:
 
-```python
-session = client.sessions.create(
-    agent_id=agent.id,
-    user_id=user.id,
-    context_overflow="adaptive"
+```Python
+会话 = 客户端.会话.创建（
+agent_id=代理.id，
+用户 ID=用户 ID，
+context_overflow="自适应"
 )
 
-# Continue conversation in the same session
-response = client.sessions.chat(
-    session_id=session.id,
-    messages=[
+# 在同一会话中继续对话
+响应 = 客户端.会话.聊天（
+session_id=会话id，
+消息=[
       {
-        "role": "user",
-        "content": "Follow up on the previous conversation."
+“角色”：“用户”，
+"content": "跟进之前的对话。"
       }
     ]
 )
 ```
 
-### 文档集成与搜索
+### Document Integration and Search
 
-轻松管理和搜索代理的文档：
+Easily manage and search through documents for your agents:
 
-```python
-# Upload a document
-document = client.agents.docs.create(
-    title="AI advancements",
-    content="AI is changing the world...",
-    metadata={"category": "research_paper"}
+```Python
+# 上传文档
+文档 = 客户端.代理.docs.创建（
+title="人工智能进步",
+content="人工智能正在改变世界...",
+元数据={“category”：“research_paper”}
 )
 
-# Search documents
-results = client.agents.docs.search(
-    text="AI advancements",
-    metadata_filter={"category": "research_paper"}
+# 搜索文档
+结果 = 客户端.代理.docs.搜索（
+text="AI 进步",
+metadata_filter={“category”：“research_paper”}
 )
 ```
 
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
+＃＃ 参考
+
+### SDK 参考
+
+- **Node.js** [SDK 参考](https://github.com/julep-ai/node-sdk/blob/main/api.md) | [NPM 包](https://www.npmjs.com/package/@julep/sdk)
+- **Python** [SDK 参考](https://github.com/julep-ai/python-sdk/blob/main/api.md) | [PyPI 包](https://pypi.org/project/julep/)
+
+### API 参考
+
+浏览我们的 API 文档以了解有关代理、任务和执行的更多信息：
+
+- [代理 API](https://dev.julep.ai/api/docs#tag/agents)
+- [任务 API]（https://dev.julep.ai/api/docs#tag/tasks）
+- [执行 API](https://dev.julep.ai/api/docs#tag/executions)
+
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
 ## 本地快速启动
 
 **要求**：
@@ -1250,22 +1526,19 @@ results = client.agents.docs.search(
 5. `cp .env.example .env # <-- 编辑此文件`
 6. `docker compose --env-file .env --profile temporary-ui --profile single-tenant --profile self-hosted-db up --build`
 
-## SDK 参考
-
-- [Node.js SDK]（https://github.com/julep-ai/node-sdk/blob/main/api.md）
-- [Python SDK]（https://github.com/julep-ai/python-sdk/blob/main/api.md）
-
-API 参考
-
-浏览我们全面的 API 文档，了解有关代理、任务和执行的更多信息：
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-- [代理 API](https://api.julep.ai/api/docs#tag/agents)
-- [任务 API](https://api.julep.ai/api/docs#tag/tasks)
-- [执行 API](https://api.julep.ai/api/docs#tag/executions)
 
 *****
 
-## 为什么选择 Julep 而不是 LangChain？
+## Julep 和 LangChain 等有什么区别？
 
 ### 不同的用例
 
@@ -1303,5 +1576,8 @@ LangChain 是一个**库**，其中包含一些工具和一个用于构建线性
 <div align="center">
     <a href="#top">
         <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
     </a>
 </div>
diff --git a/README-FR.md b/README-FR.md
index ce4cf3206..ca96b9ebd 100644
--- a/README-FR.md
+++ b/README-FR.md
@@ -6,7 +6,7 @@
 
 <p align="center">
   <br />
-  <a href="https://docs.julep.ai" rel="dofollow"><strong>Explorer les documents</strong></a>
+  <a href="https://docs.julep.ai" rel="dofollow">Explorer les documents</a>
   ·
   <a href="https://discord.com/invite/JTSBGRZrzj" rel="dofollow">Discorde</a>
   ·
@@ -62,44 +62,39 @@ Des nouvelles passionnantes ! Nous participons au DevFest.AI tout au long du moi
 
 <!-- START doctoc generated TOC please keep comment here to allow auto update -->
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
-<h3>📖 Table of Contents</h3>
+<h3>📖 Table des matières</h3>
 
-- [Introduction](#introduction)
-- [Principales caractéristiques](#principales-caract%C3%A9ristiques)
-- [Exemple rapide](#exemple-rapide)
+- [Présentation](#introduction)
+- [Caractéristiques principales](#key-features)
+- [Exemple rapide](#quick-example)
 - [Installation](#installation)
-- [Démarrage rapide de Python 🐍](#d%C3%A9marrage-rapide-de-python-)
-  - [Étape 1 : Créer un agent](#%C3%89tape-1%C2%A0-cr%C3%A9er-un-agent)
-  - [Étape 2 : Créer une tâche qui génère une histoire et une bande dessinée](#%C3%89tape-2%C2%A0-cr%C3%A9er-une-t%C3%A2che-qui-g%C3%A9n%C3%A8re-une-histoire-et-une-bande-dessin%C3%A9e)
-  - [Étape 3 : Exécuter la tâche](#%C3%89tape-3%C2%A0-ex%C3%A9cuter-la-t%C3%A2che)
-  - [Étape 4 : Discuter avec l'agent](#%C3%89tape-4%C2%A0-discuter-avec-lagent)
-- [Démarrage rapide de Node.js 🟩](#d%C3%A9marrage-rapide-de-nodejs-)
-  - [Étape 1 : Créer un agent](#%C3%89tape-1%C2%A0-cr%C3%A9er-un-agent-1)
-  - [Étape 2 : Créer une tâche qui génère une histoire et une bande dessinée](#%C3%89tape-2%C2%A0-cr%C3%A9er-une-t%C3%A2che-qui-g%C3%A9n%C3%A8re-une-histoire-et-une-bande-dessin%C3%A9e-1)
-  - [Étape 3 : Exécuter la tâche](#%C3%89tape-3%C2%A0-ex%C3%A9cuter-la-t%C3%A2che-1)
-  - [Étape 4 : Discuter avec l'agent](#%C3%89tape-4%C2%A0-discuter-avec-lagent-1)
+- [Démarrage rapide de Python 🐍](#python-quick-start-)
+- [Démarrage rapide de Node.js 🟩](#nodejs-quick-start-)
+- [Étape 1 : Créer un agent](#step-1-create-an-agent)
 - [Composants](#composants)
-  - [Modèle mental](#mod%C3%A8le-mental)
+- [Modèle mental](#mental-model)
 - [Concepts](#concepts)
-- [Comprendre les tâches](#comprendre-les-t%C3%A2ches)
-  - [Types d'étapes de flux de travail](#types-d%C3%A9tapes-de-flux-de-travail)
-- [Types d'outils](#types-doutils)
-  - [Fonctions définies par l'utilisateur](#fonctions-d%C3%A9finies-par-lutilisateur)
-  - [outils `système`](#outils-syst%C3%A8me)
-  - [« Intégrations » intégrées](#%C2%AB%C2%A0int%C3%A9grations%C2%A0%C2%BB-int%C3%A9gr%C3%A9es)
-  - [Appels directs `api_calls`](#appels-directs-api_calls)
-- [Intégrations](#int%C3%A9grations)
-- [Autres fonctionnalités](#autres-fonctionnalit%C3%A9s)
-  - [Ajout d'outils aux agents](#ajout-doutils-aux-agents)
-  - [Gestion des sessions et des utilisateurs](#gestion-des-sessions-et-des-utilisateurs)
-  - [Intégration et recherche de documents](#int%C3%A9gration-et-recherche-de-documents)
-- [Démarrage rapide local](#d%C3%A9marrage-rapide-local)
-- [Référence du SDK](#r%C3%A9f%C3%A9rence-du-sdk)
-- [Référence API](#r%C3%A9f%C3%A9rence-api)
-- [Pourquoi Julep vs. LangChain ?](#pourquoi-julep-vs-langchain%C2%A0)
-  - [Différents cas d'utilisation](#diff%C3%A9rents-cas-dutilisation)
-  - [Facteur de forme différent](#facteur-de-forme-diff%C3%A9rent)
-  - [En résumé](#en-r%C3%A9sum%C3%A9)
+- [Comprendre les tâches](#understanding-tasks)
+- [Cycle de vie d'une tâche](#cycle-de-vie-d-une-tâche)
+- [Types d'étapes de flux de travail](#types-of-workflow-steps)
+- [Types d'outils](#types-d'outils)
+- [`Fonctions` définies par l'utilisateur](#user-defined-functions)
+- [outils système](#outils-système)
+- [`Intégrations` intégrées](#integrations-integrées)
+- [Appels directs `api_calls`](#appels directs-api_calls)
+- [Intégrations](#intégrations)
+- [Autres fonctionnalités](#other-features)
+- [Ajout d'outils aux agents](#adding-tools-to-agents)
+- [Gestion des sessions et des utilisateurs](#managing-sessions-and-users)
+- [Intégration et recherche de documents](#document-integration-and-search)
+- [Référence](#référence)
+- [Référence SDK](#sdk-reference)
+- [Référence API](#api-reference)
+- [Démarrage rapide local](#local-quickstart)
+- [Quelle est la différence entre Julep et LangChain etc ?](#quelle-est-la-différence-entre-julep-et-langchain-etc)
+- [Différents cas d'utilisation](#different-use-cases)
+- [Facteur de forme différent](#different-form-factor)
+- [En résumé](#en-resumé)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
@@ -109,16 +104,16 @@ Julep est une plateforme permettant de créer des agents IA qui se souviennent d
 
 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.
+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 :
 
-Il prend en charge :
-
-- Processus complexes en plusieurs étapes
-- Prise de décision dynamique
-- Exécution parallèle
+- 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, se souvenir des interactions passées et peut-être même utiliser d'autres outils ou API. C'est là qu'intervient Julep.
+> 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](#understanding-tasks) pour en savoir plus.
 
 ## Principales caractéristiques
 
@@ -130,19 +125,25 @@ Il prend en charge :
 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.
 
-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.
+![fonctionnalités](https://github.com/user-attachments/assets/4355cbae-fcbd-4510-ac0d-f8f77b73af70)
+
+> [!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 :
 
-1. Prenez un sujet,
-2. Proposez 100 requêtes de recherche pour ce sujet,
-3. Effectuez ces recherches sur le Web en parallèle,
-4. Résumez les résultats,
-5. Envoyez le résumé sur Discord
+1. **Prenez un sujet**,
+2. **Proposez 100 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**.
 
-Dans Julep, ce serait une tâche unique sous<b>80 lignes de code</b>et courir<b>entièrement géré</b>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 :
+> [!REMARQUE]
+> Dans Julep, ce serait une tâche unique sous<b>80 lignes de code</b>et courir<b>entièrement géré</b>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 :
 
 ```yaml
 name: Research Agent
@@ -162,12 +163,12 @@ tools:
     integration:
       provider: brave
       setup:
-        api_key: "YOUR_BRAVE_API_KEY"
+        api_key: BSAqES7dj9d...  # dummy key
 
   - name: discord_webhook
     type: api_call
     api_call:
-      url: "YOUR_DISCORD_WEBHOOK_URL"
+      url: https://eobuxj02se0n.m.pipedream.net  # dummy requestbin
       method: POST
       headers:
         Content-Type: application/json
@@ -199,7 +200,7 @@ main:
       tool: web_search
       arguments:
         query: "_"
-    parallelism: 100
+    parallelism: 10
 
   # Collect the results from the web search
   - evaluate:
@@ -213,28 +214,74 @@ main:
           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: >
-        **Research Summary for {{inputs[0].topic}}**
+      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 :
+
+<details>
+<summary><b>Résumé de la recherche sur l'IA</b> <i>(Cliquez pour agrandir)</i></summary>
+
+> **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
+> 
+> 1. **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.
+> 
+> 2. **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).
+> 
+> 3. **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).
+> 
+> 4. **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é).
+> 
+> 5. **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.
+
+</details>
+
 ## Installation
 
 Pour commencer à utiliser Julep, installez-le en utilisant [npm](https://www.npmjs.com/package/@julep/sdk) ou [pip](https://pypi.org/project/julep/) :
 
+**Node.js**:
 ```bash
 npm install @julep/sdk
-```
 
-ou
+# or
+
+bun add @julep/sdk
+```
 
+**Python**:
 ```bash
 pip install julep
 ```
@@ -251,997 +298,1219 @@ pip install julep
 
 ## Démarrage rapide de Python 🐍
 
-### Étape 1 : Créer un agent
-
 ```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="gpt-4o",
-    about="You are a creative storytelling agent that can craft engaging stories and generate comic panels based on ideas.",
+    model="claude-3.5-sonnet",
+    about="You are a creative storyteller that crafts engaging stories on a myriad of topics.",
 )
 
-# 🛠️ Add an image generation tool (DALL·E) to the agent
-client.agents.tools.create(
-    agent_id=agent.id,
-    name="image_generator",
-    description="Use this tool to generate images based on descriptions.",
-    integration={
-        "provider": "dalle",
-        "method": "generate_image",
-        "setup": {
-            "api_key": "your_openai_api_key",
-        },
-    },
-)
-```
-
-### Étape 2 : Créer une tâche qui génère une histoire et une bande dessinée
+### Step 2: Create a Task that generates a story and comic strip
 
-Définissons une tâche en plusieurs étapes pour créer une histoire et générer une bande dessinée à panneaux basée sur une idée d'entrée :
-
-```python
-# 📋 Task
-# Create a task that takes an idea and creates a story and a 4-panel comic strip
 task_yaml = """
-name: Story and Comic Creator
-description: Create a story based on an idea and generate a 4-panel comic strip illustrating the story.
+name: Storyteller
+description: Create a story based on an idea.
+
+tools:
+  - name: research_wikipedia
+    integration:
+      provider: wikipedia
+      method: search
 
 main:
-  # Step 1: Generate a story and outline into 4 panels
+  # Step 1: Generate plot idea
   - prompt:
       - role: system
         content: You are {{agent.name}}. {{agent.about}}
       - role: user
         content: >
-          Based on the idea '{{_.idea}}', write a short story suitable for a 4-panel comic strip.
-          Provide the story and a numbered list of 4 brief descriptions for each panel illustrating key moments in the story.
+          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
 
-  # Step 2: Extract the panel descriptions and story
   - evaluate:
-      story: _.split('1. ')[0].strip()
-      panels: re.findall(r'\\d+\\.\\s*(.*?)(?=\\d+\\.\\s*|$)', _)
+      research_queries: load_yaml(_.split('```yaml')[1].split('```')[0].strip())
 
-  # Step 3: Generate images for each panel using the image generator tool
+  # Step 3: Research each plot idea
   - foreach:
-      in: _.panels
+      in: _.research_queries
       do:
-        tool: image_generator
+        tool: research_wikipedia
         arguments:
-          description: _
+          query: _
+
+  - evaluate:
+      wikipedia_results: 'NEWLINE.join([f"- {doc.metadata.title}: {doc.metadata.summary}" for item in _ for doc in item.documents])'
 
-  # Step 4: Generate a catchy title for the story
+  # Step 4: Think and deliberate
   - prompt:
       - role: system
         content: You are {{agent.name}}. {{agent.about}}
       - role: user
-        content: >
-          Based on the story below, generate a catchy title.
-
-          Story: {{outputs[1].story}}
-    unwrap: true
-
-  # Step 5: Return the story, the generated images, and the title
-  - return:
-      title: outputs[3]
-      story: outputs[1].story
-      comic_panels: "[output.image.url for output in outputs[2]]"
+        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())"
 """
 
-task = client.tasks.create(
-    agent_id=agent.id,
-    **yaml.safe_load(task_yaml)
+tâche = client.tasks.create(
+agent_id=agent.id,
+**yaml.safe_load(tâche_yaml)
 )
-```
 
 ### Étape 3 : Exécuter la tâche
 
-```python
-# 🚀 Execute the task with an input idea
-execution = client.executions.create(
-    task_id=task.id,
-    input={"idea": "A cat who learns to fly"}
+exécution = client.executions.create(
+task_id=task.id,
+input={"idea": "Un chat qui apprend à voler"}
 )
 
-# 🎉 Watch as the story and comic panels are generated
-for transition in client.executions.transitions.stream(execution_id=execution.id):
-    print(transition)
+# 🎉 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)
 
-# 📦 Once the execution is finished, retrieve the results
-result = client.executions.get(execution_id=execution.id)
+# 📦 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)
 ```
 
-### Étape 4 : Discuter avec l'agent
-
-Démarrez une session de chat interactive avec l'agent :
-
-```python
-session = client.sessions.create(agent_id=agent.id)
-
-# 💬 Send messages to the agent
-while (message := input("Enter a message: ")) != "quit":
-    response = client.sessions.chat(
-        session_id=session.id,
-        message=message,
-    )
-
-    print(response)
-```
+You can find the full python example [here](example.py).
 
-Vous pouvez trouver l'exemple Python complet [ici](example.py).
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-## Démarrage rapide de Node.js 🟩
+## Node.js Quick Start 🟩
 
-### Étape 1 : Créer un agent
+### Step 1: Create an Agent
 
 ```javascript
-import { Julep } from "@julep/sdk";
-import yaml from "js-yaml";
+// Étape 0 : Configuration
+const dotenv = require('dotenv');
+const { Julep } = require('@julep/sdk');
+const yaml = require('yaml');
 
-const client = new Julep({ apiKey: "your_julep_api_key" });
+dotenv.config();
 
-async function createAgent() {
-  const agent = await client.agents.create({
-    name: "Storytelling Agent",
-    model: "gpt-4",
-    about:
-      "You are a creative storytelling agent that can craft engaging stories and generate comic panels based on ideas.",
-  });
+const client = new Julep({ apiKey: process.env.JULEP_API_KEY, environnement: process.env.JULEP_ENVIRONMENT || "production" });
 
-  // 🛠️ Add an image generation tool (DALL·E) to the agent
-  await client.agents.tools.create(agent.id, {
-    name: "image_generator",
-    description: "Use this tool to generate images based on descriptions.",
-    integration: {
-      provider: "dalle",
-      method: "generate_image",
-      setup: {
-        api_key: "your_openai_api_key",
-      },
-    },
-  });
+/* Étape 1 : Créer un agent */
 
-  return 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
-
-```javascript
-const taskYaml = `
-name: Story and Comic Creator
-description: Create a story based on an idea and generate a 4-panel comic strip illustrating the story.
 
-main:
-  # Step 1: Generate a story and outline into 4 panels
-  - prompt:
-      - role: system
-        content: You are {{agent.name}}. {{agent.about}}
-      - role: user
-        content: >
-          Based on the idea '{{_.idea}}', write a short story suitable for a 4-panel comic strip.
-          Provide the story and a numbered list of 4 brief descriptions for each panel illustrating key moments in the story.
-    unwrap: true
-
-  # Step 2: Extract the panel descriptions and story
-  - evaluate:
-      story: _.split('1. ')[0].trim()
-      panels: _.match(/\\d+\\.\\s*(.*?)(?=\\d+\\.\\s*|$)/g)
-
-  # Step 3: Generate images for each panel using the image generator tool
-  - foreach:
-      in: _.panels
-      do:
-        tool: image_generator
-        arguments:
-          description: _
-
-  # Step 4: Generate a catchy title for the story
-  - prompt:
-      - role: system
-        content: You are {{agent.name}}. {{agent.about}}
-      - role: user
-        content: >
-          Based on the story below, generate a catchy title.
-
-          Story: {{outputs[1].story}}
-    unwrap: true
-
-  # Step 5: Return the story, the generated images, and the title
-  - return:
-      title: outputs[3]
-      story: outputs[1].story
-      comic_panels: outputs[2].map(output => output.image.url)
+/* É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()) »
 `;
 
-async function createTask(agent) {
-  const task = await client.tasks.create(agent.id, yaml.load(taskYaml));
-  return task;
+fonction asynchrone createTask(agentId) {
+const tâche = attendre client.tasks.create(
+identifiant de l'agent,
+yaml.parse(tâcheYaml)
+  );
+tâche de retour;
 }
-```
 
-### Étape 3 : Exécuter la tâche
+/* Étape 3 : Exécuter la tâche */
 
-```javascript
-async function executeTask(task) {
-  const execution = await client.executions.create(task.id, {
-    input: { idea: "A cat who learns to fly" },
+fonction asynchrone executeTask(taskId) {
+const exécution = attendre client.executions.create(taskId, {
+entrée : { idée : "Un chat qui apprend à voler" }
   });
 
-  // 🎉 Watch as the story and comic panels are generated
-  for await (const transition of client.executions.transitions.stream(
-    execution.id
-  )) {
-    console.log(transition);
-  }
-
-  // 📦 Once the execution is finished, retrieve the results
-  const result = await client.executions.get(execution.id);
-  return result;
-}
-```
-
-### Étape 4 : Discuter avec l'agent
-
-```javascript
-async function chatWithAgent(agent) {
-  const session = await client.sessions.create({ agent_id: agent.id });
-
-  // 💬 Send messages to the agent
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-  const chat = async () => {
-    rl.question("Enter a message (or 'quit' to exit): ", async (message) => {
-      if (message.toLowerCase() === "quit") {
-        rl.close();
-        return;
+// 🎉 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;
+    }
 
-      const response = await client.sessions.chat(session.id, { message });
-      console.log(response);
-      chat();
-    });
-  };
-
-  chat();
+attendre une nouvelle promesse (résolution => setTimeout (résolution, 1000));
+  }
 }
 
-// Run the example
-async function runExample() {
-  const agent = await createAgent();
-  const task = await createTask(agent);
-  const result = await executeTask(task);
-  console.log("Task Result:", result);
-  await chatWithAgent(agent);
+// 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);
+  }
 }
 
-runExample().catch(console.error);
+main().then(() => console.log("Terminé")).catch(console.error);
 ```
 
-Vous pouvez trouver l'exemple complet de Node.js [ici](example.js).
+You can find the full Node.js example [here](example.js).
 
-## Composants
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
+## Components
 
-Julep est composé des éléments suivants :
+Julep is made up of the following components:
 
-- **Plateforme Julep** : la plateforme Julep est un service cloud qui exécute vos workflows. Elle comprend un langage pour décrire les workflows, un serveur pour exécuter ces workflows et un SDK pour interagir avec la plateforme.
-- **SDK Julep** : les SDK Julep sont un ensemble de bibliothèques permettant de créer des workflows. Il existe des SDK pour Python et JavaScript, et d'autres sont en cours de développement.
-- **API Julep** : L'API Julep est une API RESTful que vous pouvez utiliser pour interagir avec la plateforme Julep.
+- **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.
 
-### Modèle mental
+### Mental Model
 
 <div align="center">
   <img src="https://github.com/user-attachments/assets/38420b5d-9342-4c8d-bae9-b47c28ae45af" height="360" />
 </div>
 
-Considérez Julep comme une plateforme qui combine des composants côté client et côté serveur pour vous aider à créer des agents d'IA avancés. Voici comment le visualiser :
+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. **Votre code d'application :**
+1. **Your Application Code:**
 
-- Vous pouvez utiliser le SDK Julep dans votre application pour définir des agents, des tâches et des workflows.
-- Le SDK fournit des fonctions et des classes qui facilitent la configuration et la gestion de ces composants.
+   - 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. **Service back-end Julep :**
+2. **Julep Backend Service:**
 
-- Le SDK communique avec le backend Julep via le réseau.
-- Le backend gère l'exécution des tâches, maintient l'état de la session, stocke les documents et orchestre les flux de travail.
+   - 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. **Intégration avec les outils et les API :**
-- Au sein de vos workflows, vous pouvez intégrer des outils et services externes.
-- Le backend facilite ces intégrations, afin que vos agents puissent, par exemple, effectuer des recherches sur le Web, accéder à des bases de données ou appeler des API tierces.
+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.
 
 ## Concepts
 
-Julep s'appuie sur plusieurs composants techniques clés qui fonctionnent ensemble pour créer de puissants flux de travail d'IA :
+Julep is built on several key technical components that work together to create powerful AI workflows:
 
-```mermaid
-graph TD
-    User[User] ==> Session[Session]
-    Session --> Agent[Agent]
-    Agent --> Tasks[Tasks]
-    Agent --> LLM[Large Language Model]
-    Tasks --> Tools[Tools]
-    Agent --> Documents[Documents]
-    Documents --> VectorDB[Vector Database]
-    Tasks --> Executions[Executions]
+```sirène
+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]
 
-    classDef client fill:#9ff,stroke:#333,stroke-width:1px;
-    class User client;
+client classDef fill:#9ff,trait:#333,largeur-trait:1px;
+classe Utilisateur client ;
 
-    classDef core fill:#f9f,stroke:#333,stroke-width:2px;
-    class Agent,Tasks,Session core;
+classDef core fill:#f9f,trait:#333,largeur-trait:2px;
+classe Agent,Tâches,Session core;
 ```
 
-- **Agents** : entités alimentées par l'IA et soutenues par de grands modèles linguistiques (LLM) qui exécutent des tâches et interagissent avec les utilisateurs.
-- **Utilisateurs** : entités qui interagissent avec les agents via des sessions.
-- **Sessions** : interactions avec état entre agents et utilisateurs, maintenant le contexte sur plusieurs échanges.
-- **Tâches** : flux de travail programmatiques en plusieurs étapes que les agents peuvent exécuter, y compris différents types d'étapes telles que des invites, des appels d'outils et une logique conditionnelle.
-- **Outils** : intégrations qui étendent les capacités d'un agent, y compris les fonctions définies par l'utilisateur, les outils système ou les intégrations d'API tierces.
-- **Documents** : Objets textes ou données associés à des agents ou utilisateurs, vectorisés et stockés pour la recherche et la récupération sémantiques.
-- **Exécutions** : instances de tâches qui ont été initiées avec des entrées spécifiques, avec leur propre cycle de vie et leur propre machine d'état.
+- **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.
+
+
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
+## 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:
 
-Pour une explication plus détaillée, reportez-vous à notre [Documentation des concepts](https://github.com/julep-ai/julep/blob/dev/docs/julep-concepts.md).
+- **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](#types-of-workflow-steps) for more details)
+- **Tools**: Optional integrations that extend the capabilities of your agent during task execution.
 
-## Comprendre les tâches
+### Lifecycle of a Task
 
-Les tâches sont au cœur du système de workflow de Julep. Elles vous permettent de définir des workflows IA complexes en plusieurs étapes que vos agents peuvent exécuter. Voici un bref aperçu des composants des tâches :
+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:
 
-- **Nom et description** : Chaque tâche a un nom et une description uniques pour une identification facile.
-- **Étapes principales** : Le cœur d’une tâche, définissant la séquence d’actions à effectuer.
-- **Outils** : intégrations facultatives qui étendent les capacités de votre agent pendant l'exécution des tâches.
+```sirène
+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 d'étapes de flux de travail
+### Types of Workflow Steps
 
-Les tâches dans Julep peuvent inclure différents types d'étapes, ce qui vous permet de créer des flux de travail complexes et puissants. Voici un aperçu des types d'étapes disponibles :
+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:
 
-#### Étapes courantes
+#### Common Steps
 
 <table>
 <tr>
-<td>Nom</td> <td>À propos</td><td>Syntaxe</td>
+    <th>Name</th>
+    <th>About</th>
+    <th>Syntax</th>
 </tr>
 <tr>
-<td>Rapide</td>
+<td> <b>Prompt</b> </td>
 <td>
-Envoyez un message au modèle d'IA et recevez une réponse
-
+Send a message to the AI model and receive a response
+<br><br><b>Note:</b> The prompt step uses Jinja templates and you can access context variables in them.
 </td>
 
 <td>
 
-```yaml
-- prompt: "Analyze the following data: {{data}}"
+```YAML
+- invite : « Analyser les données suivantes : {{agent.name}} » # <-- ceci est un modèle jinja
+```
+
+```YAML
+- rapide:
+- rôle : système
+contenu : « Vous êtes {{agent.name}}. {{agent.about}} »
+- rôle : utilisateur
+contenu : « Analysez les données suivantes : {{_.data}} »
 ```
 
 </td>
 </tr>
 <tr>
-<td>Appel d'outil</td>
+<td> <b>Tool Call</b> </td>
 <td>
-Exécuter un outil intégré ou une API
+Execute an integrated tool or API that you have previously declared in the task.
+<br><br><b>Note:</b> The tool call step uses Python expressions inside the arguments.
 
 </td>
 
 <td>
 
-```yaml
-- tool: web_search
-  arguments:
-    query: "Latest AI developments"
+```YAML
+- 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
 ```
 
 </td>
 </tr>
 <tr>
-<td>Évaluer</td>
+<td> <b>Evaluate</b> </td>
 <td>
-Effectuer des calculs ou manipuler des données
-
+Perform calculations or manipulate data
+<br><br><b>Note:</b> The evaluate step uses Python expressions.
 </td>
 
 <td>
 
-```yaml
-- evaluate:
-    average_score: "sum(scores) / len(scores)"
+```YAML
+- évaluer:
+average_score : somme(scores) / len(scores)
 ```
 
 </td>
 </tr>
 <tr>
-<td>Attendre l'entrée</td>
+<td> <b>Wait for Input</b> </td>
 <td>
-Suspendre le flux de travail jusqu'à ce que les données soient reçues
+Pause workflow until input is received. It accepts an `info` field that can be used by your application to collect input from the user.
+
+<br><br><b>Note:</b> 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.
 
 </td>
 
 <td>
 
-```yaml
-- wait_for_input:
-    info:
-      message: "Please provide additional information."
+```YAML
+- attendre_la_saisie :
+info:
+message : « Veuillez fournir des informations supplémentaires sur {_.required_info}. » # <-- expression Python pour accéder à la variable de contexte
 ```
 
 </td>
 </tr>
 <tr>
-<td>Enregistrer</td>
+<td> <b>Log</b> </td>
 <td>
-Enregistrer une valeur ou un message spécifié
+Log a specified value or message.
+
+<br><br><b>Note:</b> The log step uses Jinja templates and you can access context variables in them.
 
 </td>
 
 <td>
 
-```yaml
-- log: "Processing completed for item {{item_id}}"
+```YAML
+- log : « Traitement terminé pour l'élément {{_.item_id}} » # <-- modèle jinja pour accéder à la variable de contexte
 ```
 
 </td>
 </tr>
 </table>
 
-#### Étapes clé-valeur
+#### Key-Value Steps
 
 <table>
 <tr>
-<td>Nom</td> <td>À propos</td><td>Syntaxe</td>
+<th> Name </th> <th> About </th><th>Syntax</th>
 </tr>
 <tr>
-<td>Obtenir</td>
+<td> <b>Get</b> </td>
 <td>
-Récupérer une valeur d'un magasin clé-valeur
+Retrieve a value from the execution's key-value store.
 
 </td>
 
 <td>
 
-```yaml
-- get: "user_preference"
+```YAML
+- obtenir : préférences_utilisateur
 ```
 
 </td>
 </tr>
 <tr>
-<td>Ensemble</td>
+<td> <b>Set</b> </td>
 <td>
-Attribuer une valeur à une clé dans un magasin clé-valeur
+Assign a value to a key in the execution's key-value store.
 
+<br><br><b>Note:</b> The set step uses Python expressions.
 </td>
 
 <td>
 
-```yaml
-- set:
-    user_preference: "dark_mode"
+```YAML
+- ensemble:
+préférence_utilisateur : '"dark_mode"' # <-- expression python
 ```
 
 </td>
 </tr>
 </table>
 
-#### Étapes d'itération
+#### Iteration Steps
 
 <table>
 <tr>
-<td>Nom</td> <td>À propos</td><td>Syntaxe</td>
+<th> Name </th> <th> About </th><th>Syntax</th>
 </tr>
 <tr>
-<td>Pour chaque</td>
+<td> <b>Foreach</b> </td>
 <td>
-Itérer sur une collection et effectuer des étapes pour chaque élément
+Iterate over a collection and perform steps for each item
 
 </td>
 
 <td>
 
-```yaml
-- foreach:
-    in: "data_list"
-    do:
-      - log: "Processing item {{_}}"
+```YAML
+- 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
 ```
 
 </td>
 </tr>
 <tr>
-<td>Carte-Réduction</td>
+<td> <b>Map-Reduce</b> </td>
 <td>
-Cartographier une collection et réduire les résultats
+Map over a collection and reduce the results
 
 </td>
 
 <td>
 
-```yaml
+```YAML
 - map_reduce:
-    over: "numbers"
-    map:
-      - evaluate:
-          squared: "_ ** 2"
-    reduce: "sum(results)"
+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.
+```
+
+```YAML
+- map_reduce:
+plus de: _.topics
+carte:
+- invite : Rédigez un essai sur {{_}}
+parallélisme : 10
 ```
 
 </td>
 </tr>
 <tr>
-<td>Parallèle</td>
+<td> <b>Parallel</b> </td>
 <td>
-Exécuter plusieurs étapes en parallèle
+Run multiple steps in parallel
 
 </td>
 
 <td>
 
-```yaml
-- parallel:
-    - tool: web_search
-      arguments:
-        query: "AI news"
-    - tool: weather_check
-      arguments:
-        location: "New York"
+```YAML
+- parallèle:
+- outil : recherche_sur_le_web
+Arguments:
+requête : « Actualités sur l'IA »
+- outil : weather_check
+Arguments:
+Lieu : « New York »
 ```
 
 </td>
 </tr>
 </table>
 
-#### Étapes conditionnelles
+#### Conditional Steps
 
 <table>
 <tr>
-<td>Nom</td> <td>À propos</td><td>Syntaxe</td>
+<th> Name </th> <th> About </th><th>Syntax</th>
 </tr>
 <tr>
-<td>Si-Sinon</td>
+<td> <b>If-Else</b> </td>
 <td>
-Exécution conditionnelle des étapes
+Conditional execution of steps
 
 </td>
 
 <td>
 
-```yaml
-- if: "score > 0.8"
-  then:
-    - log: "High score achieved"
-  else:
-    - log: "Score needs improvement"
+```YAML
+- si : _.score > 0.8 # <-- expression python
+alors:
+- log : score élevé atteint
+autre:
+- erreur : le score doit être amélioré
 ```
 
 </td>
 </tr>
 <tr>
-<td>Changer</td>
+<td> <b>Switch</b> </td>
 <td>
-Exécuter des étapes en fonction de plusieurs conditions
+Execute steps based on multiple conditions
 
 </td>
 
 <td>
 
-```yaml
-- switch:
-    - case: "category == 'A'"
-      then:
-        - log: "Category A processing"
-    - case: "category == 'B'"
-      then:
-        - log: "Category B processing"
-    - case: "_" # Default case
-      then:
-        - log: "Unknown category"
+```YAML
+- 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
 ```
 
 </td>
 </tr>
 </table>
 
-#### Autre flux de contrôle
+#### Other Control Flow
 
 <table>
 <tr>
-<td>Nom</td> <td>À propos</td><td>Syntaxe</td>
+<th> Name </th> <th> About </th><th>Syntax</th>
 </tr>
 <tr>
-<td>Dormir</td>
+<td> <b>Sleep</b> </td>
 <td>
-Suspendre le flux de travail pendant une durée spécifiée
+Pause the workflow for a specified duration
 
 </td>
 
 <td>
 
-```yaml
-- sleep:
-    seconds: 30
+```YAML
+- dormir:
+secondes: 30
+# minutes: 1
+# heures: 1
+# jours: 1
 ```
 
 </td>
 </tr>
 <tr>
-<td>Retour</td>
+<td> <b>Return</b> </td>
 <td>
-Renvoyer une valeur du workflow
+Return a value from the workflow
+
+<br><br><b>Note:</b> The return step uses Python expressions.
 
 </td>
 
 <td>
 
-```yaml
-- return:
-    result: "Task completed successfully"
+```YAML
+- retour:
+résultat : " Tâche terminée avec succès " # <-- expression python
+heure : datetime.now().isoformat() # <-- expression python
 ```
 
 </td>
 </tr>
 <tr>
-<td>Rendement</td>
+<td> <b>Yield</b> </td>
 <td>
-Exécuter un sous-workflow et attendre sa fin
+Run a subworkflow and await its completion
 
 </td>
 
 <td>
 
-```yaml
-- yield:
-    workflow: "data_processing_subflow"
-    arguments:
-      input_data: "{{raw_data}}"
+```YAML
+- rendement:
+flux de travail : données_de_processus
+Arguments:
+données d'entrée : _. données brutes # <-- expression Python
 ```
 
 </td>
 </tr>
 </tr>
 <tr>
-<td>Erreur</td>
+<td> <b>Error</b> </td>
 <td>
-Gérer les erreurs en spécifiant un message d'erreur
+Handle errors by specifying an error message
 
 </td>
 
 <td>
 
-```yaml
-- error: "Invalid input provided"
+```YAML
+- erreur : « Entrée non valide fournie » # <-- Chaînes uniquement
 ```
 
 </td>
 </tr>
 </table>
 
-Chaque type d'étape remplit un objectif spécifique dans la création de workflows d'IA sophistiqués. Cette catégorisation permet de comprendre les différents flux de contrôle et opérations disponibles dans les tâches Julep.
+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.
+
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-## Types d'outils
+## Tool Types
 
-Les agents peuvent avoir accès à un certain nombre d'« outils » : toute interface de programmation qu'un modèle de base peut « appeler » avec un ensemble d'entrées pour atteindre un objectif. Par exemple, il peut utiliser un outil « web_search(query) » pour rechercher des informations sur Internet.
+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.
 
-Contrairement aux frameworks d'agents, Julep est un backend qui gère l'exécution des agents. Les clients peuvent interagir avec les agents à l'aide de nos SDK. Julep s'occupe de l'exécution des tâches et de l'exécution des intégrations.
+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.
 
-Les outils du julep peuvent être l’un des suivants :
+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.
 
-### Fonctions définies par l'utilisateur
+### User-defined `functions`
 
-Il s'agit de signatures de fonctions que vous pouvez attribuer au modèle pour qu'il puisse choisir, de la même manière que fonctionne l'appel de fonctions d'[openai]. Un exemple :
+These are function signatures that you can give the model to choose from, similar to how [openai]'s function-calling works. An example:
 
-```yaml
-name: Example system tool task
-description: List agents using system call
+```YAML
+nom : Exemple de tâche d'outil système
+description : Lister les agents à l'aide d'un appel système
 
-tools:
-  - name: send_notification
-    description: Send a notification to the user
-    type: function
-    function:
-      parameters:
-        type: object
-        properties:
-          text:
-            type: string
-            description: Content of the notification
+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
 
-main:
-  - tool: send_notification
-    arguments:
-      content: hi
+principal:
+- outil : send_notification
+Arguments:
+contenu : '"salut"' # <-- expression python
 ```
 
-Chaque fois que julep rencontre une _fonction définie par l'utilisateur_, il s'arrête, rend le contrôle au client et attend que le client exécute l'appel de fonction et renvoie les résultats à julep.
+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]
-> **Exemple de livre de recettes** : [cookbooks/13-Error_Handling_and_Recovery.py](https://github.com/julep-ai/julep/blob/dev/cookbooks/13-Error_Handling_and_Recovery.py)
+> **Example cookbook**: [cookbooks/13-Error_Handling_and_Recovery.py](https://github.com/julep-ai/julep/blob/dev/cookbooks/13-Error_Handling_and_Recovery.py)
 
-### outils `système`
+### `system` tools
 
-Outils intégrés qui peuvent être utilisés pour appeler les API julep elles-mêmes, comme déclencher l'exécution d'une tâche, ajouter à un champ de métadonnées, etc.
-Les outils « système » sont intégrés au backend. Ils sont exécutés automatiquement lorsque cela est nécessaire. Ils ne nécessitent aucune action du côté client.
+Built-in tools that can be used to call the julep APIs themselves, like triggering a task execution, appending to a metadata field, etc.  
 
-Par exemple,
+`system` tools are built into the backend. They get executed automatically when needed. They do _not_ require any action from the client-side.
 
-```yaml
-name: Example system tool task
-description: List agents using system call
+For example,
 
-tools:
-  - name: list_agents
-    description: List all agents
-    type: system
-    system:
-      resource: agent
-      operation: list
-main:
-  - tool: list_agents
-    arguments:
-      limit: 10
-```
+```YAML
+nom : Exemple de tâche d'outil système
+description : Lister les agents à l'aide d'un appel système
 
-> [!TIP]
-> **Exemple de livre de recettes** : [cookbooks/10-Document_Management_and_Search.py](https://github.com/julep-ai/julep/blob/dev/cookbooks/10-Document_Management_and_Search.py)
+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
 
-### « Intégrations » intégrées
+principal:
+- outil : list_agents
+Arguments:
+limite : 10 # <-- expression python
+```
 
-Julep est livré avec un certain nombre d'intégrations intégrées (comme décrit dans la section ci-dessous). Les outils « d'intégration » sont directement exécutés sur le backend de Julep. Tous les paramètres supplémentaires dont ils ont besoin au moment de l'exécution peuvent être définis dans les champs « métadonnées » de l'agent/session/utilisateur.
+#### 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]
-> **Exemple de livre de recettes** : [cookbooks/01-Website_Crawler_using_Spider.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/01-Website_Crawler_using_Spider.ipynb)
+> **Example cookbook**: [cookbooks/10-Document_Management_and_Search.py](https://github.com/julep-ai/julep/blob/dev/cookbooks/10-Document_Management_and_Search.py)
 
-Le backend Julep est livré avec des outils tiers intégrés provenant des fournisseurs suivants :
+### Built-in `integrations`
 
-- [composio](https://composio.dev)
-- [anonyme](https://anon.com)
-- [boîtes à outils langchain](https://python.langchain.com/v0.2/docs/integrations/toolkits/)
+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.
 
-La prise en charge des boîtes à outils _Github, Gitlab, Gmail, Jira, MultiOn, Slack_ est prévue.
+See [Integrations](#integrations) for details on the available integrations.
 
-Étant donné que _composio_ et _anon_ sont des fournisseurs tiers, leurs outils nécessitent la configuration d'une liaison de compte.
+> [!TIP]
+> **Example cookbook**: [cookbooks/01-Website_Crawler_using_Spider.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/01-Website_Crawler_using_Spider.ipynb)
 
-### Appels directs `api_calls`
 
-julep peut également effectuer directement des appels d'API lors des exécutions de workflows sous forme d'appels d'outils. Comme pour `integration`, des paramètres d'exécution supplémentaires sont chargés à partir des champs `metadata`.
+### Direct `api_calls`
 
-Par exemple,
+julep can also directly make api calls during workflow executions as tool calls. Same as `integration`s, additional runtime parameters are loaded from `metadata` fields.
 
-```yaml
-name: Example api_call task
-tools:
-  - type: api_call
-    name: hello
-    api_call:
-      method: GET
-      url: https://httpbin.org/get
-main:
-  - tool: hello
-    arguments:
-      params:
-        test: _.input
+For example,
+
+```YAML
+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
 ```
 
-## Intégrations
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
+## Integrations
 
-Julep prend en charge diverses intégrations qui étendent les capacités de vos agents IA. Voici une liste des intégrations disponibles et de leurs arguments pris en charge :
+Julep supports various integrations that extend the capabilities of your AI agents. Here's a list of available integrations and their supported arguments:
 
 <table>
 
 <tr>
-<td>Recherche courageuse</td>
+<td> <b>Brave Search</b> </td>
 <td>
 
-```yaml
-setup:
-  api_key: string # The API key for Brave Search
+```YAML
+installation:
+api_key : chaîne # La clé API pour Brave Search
 
-arguments:
-  query: string # The search query for searching with Brave
+Arguments:
+requête : chaîne # La requête de recherche pour rechercher avec Brave
 
-output:
-  result: string # The result of the Brave Search
+sortir:
+résultat : chaîne # Le résultat de la recherche Brave
 ```
 
 </td>
 
 <td>
 
-**Exemple de livre de recettes** : [cookbooks/03-SmartResearcher_With_WebSearch.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/03-SmartResearcher_With_WebSearch.ipynb)
+**Example cookbook**: [cookbooks/03-SmartResearcher_With_WebSearch.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/03-SmartResearcher_With_WebSearch.ipynb)
 
 </td>
 </tr>
 <tr>
-<td>Base de navigateur</td>
+<td> <b>BrowserBase</b> </td>
 <td>
 
-```yaml
-setup:
-  api_key: string # The API key for BrowserBase
-  project_id: string # The project ID for BrowserBase
-  session_id: string # (Optional) The session ID for BrowserBase
+```YAML
+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: list[string] # The URLs for loading with BrowserBase
+Arguments:
+urls : liste[chaîne] # Les URL pour le chargement avec BrowserBase
 
-output:
-  documents: list # The documents loaded from the URLs
+sortir:
+documents : liste # Les documents chargés à partir des URL
 ```
 
 </td>
 
 </tr>
 <tr>
-<td>E-mail</td>
+<td> <b>Email</b> </td>
 <td>
 
-```yaml
-setup:
-  host: string # The host of the email server
-  port: integer # The port of the email server
-  user: string # The username of the email server
-  password: string # The password of the email server
-
-arguments:
-  to: string # The email address to send the email to
-  from: string # The email address to send the email from
-  subject: string # The subject of the email
-  body: string # The body of the email
-
-output:
-  success: boolean # Whether the email was sent successfully
+```YAML
+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
 ```
 
 </td>
 
 <td>
 
-**Exemple de livre de recettes** : [cookbooks/00-Devfest-Email-Assistant.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/00-Devfest-Email-Assistant.ipynb)
+**Example cookbook**: [cookbooks/00-Devfest-Email-Assistant.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/00-Devfest-Email-Assistant.ipynb)
 
 </td>
 </tr>
 <tr>
-<td>Araignée</td>
+<td> <b>Spider</b> </td>
 <td>
 
-```yaml
-setup:
-  spider_api_key: string # The API key for Spider
+```YAML
+installation:
+spider_api_key : chaîne # La clé API pour Spider
 
-arguments:
-  url: string # The URL for which to fetch data
-  mode: string # The type of crawlers (default: "scrape")
-  params: dict # (Optional) The parameters for the Spider API
+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
 
-output:
-  documents: list # The documents returned from the spider
+sortir:
+documents : liste # Les documents renvoyés par l'araignée
 ```
 
 </td>
 
 <td>
 
-**Exemple de livre de recettes** : [cookbooks/01-Website_Crawler_using_Spider.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/01-Website_Crawler_using_Spider.ipynb)
+**Example cookbook**: [cookbooks/01-Website_Crawler_using_Spider.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/01-Website_Crawler_using_Spider.ipynb)
 
 </td>
 </tr>
 <tr>
-<td>Météo</td>
+<td> <b>Weather</b> </td>
 <td>
 
-```yaml
-setup:
-  openweathermap_api_key: string # The API key for OpenWeatherMap
+```YAML
+installation:
+openweathermap_api_key : chaîne # La clé API pour OpenWeatherMap
 
-arguments:
-  location: string # The location for which to fetch weather data
+Arguments:
+emplacement : chaîne # L'emplacement pour lequel récupérer les données météorologiques
 
-output:
-  result: string # The weather data for the specified location
+sortir:
+résultat : chaîne # Les données météorologiques pour l'emplacement spécifié
 ```
 
 </td>
 
 <td>
 
-**Exemple de livre de recettes** : [cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb)
+**Example cookbook**: [cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb)
 
 </td>
 </tr>
 </tr>
 <tr>
-<td>Wikipédia</td>
+<td> <b>Wikipedia</b> </td>
 <td>
 
-```yaml
-arguments:
-  query: string # The search query string
-  load_max_docs: integer # Maximum number of documents to load (default: 2)
+```YAML
+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)
 
-output:
-  documents: list # The documents returned from the Wikipedia search
+sortir:
+documents : liste # Les documents renvoyés par la recherche sur Wikipédia
 ```
 
 </td>
 
 <td>
 
-**Exemple de livre de recettes** : [cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb)
+**Example cookbook**: [cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb)
 
 </td>
 </tr>
 </table>
 
-Pour plus de détails, reportez-vous à notre [Documentation sur les intégrations](https://docs.julep.ai/integrations).
+For more details, refer to our [Integrations Documentation](#integrations).
 
-## Autres fonctionnalités
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
+## Other Features
 
-Julep propose une gamme de fonctionnalités avancées pour améliorer vos flux de travail d'IA :
+Julep offers a range of advanced features to enhance your AI workflows:
 
-### Ajout d'outils aux agents
+### Adding Tools to Agents
 
-Étendez les capacités de votre agent en intégrant des outils et des API externes :
+Extend your agent's capabilities by integrating external tools and APIs:
 
 ```python
-client.agents.tools.create(
-    agent_id=agent.id,
-    name="web_search",
-    description="Search the web for information.",
-    integration={
-        "provider": "brave",
-        "method": "search",
-        "setup": {"api_key": "your_brave_api_key"},
+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"},
     },
 )
 ```
 
-### Gestion des sessions et des utilisateurs
+### Managing Sessions and Users
 
-Julep fournit une gestion de session robuste pour les interactions persistantes :
+Julep provides robust session management for persistent interactions:
 
 ```python
 session = client.sessions.create(
-    agent_id=agent.id,
-    user_id=user.id,
-    context_overflow="adaptive"
+agent_id=agent.id,
+user_id=utilisateur.id,
+context_overflow="adaptatif"
 )
 
-# Continue conversation in the same session
-response = client.sessions.chat(
-    session_id=session.id,
-    messages=[
+# Poursuivre la conversation dans la même session
+réponse = client.sessions.chat(
+session_id=session.id,
+messages=[
       {
-        "role": "user",
-        "content": "Follow up on the previous conversation."
+"rôle": "utilisateur",
+« contenu » : « Suivi de la conversation précédente. »
       }
     ]
 )
 ```
 
-### Intégration et recherche de documents
+### Document Integration and Search
 
-Gérez et recherchez facilement des documents pour vos agents :
+Easily manage and search through documents for your agents:
 
 ```python
-# Upload a document
+# Télécharger un document
 document = client.agents.docs.create(
-    title="AI advancements",
-    content="AI is changing the world...",
-    metadata={"category": "research_paper"}
+titre="Progrès de l'IA",
+content="L'IA change le monde...",
+métadonnées={"category": "article_de_recherche"}
 )
 
-# Search documents
-results = client.agents.docs.search(
-    text="AI advancements",
-    metadata_filter={"category": "research_paper"}
+# Rechercher des documents
+résultats = client.agents.docs.search(
+texte="Progrès de l'IA",
+metadata_filter={"category": "article_de_recherche"}
 )
 ```
 
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
+## Référence
+
+### Référence du SDK
+
+- **Node.js** [Référence SDK](https://github.com/julep-ai/node-sdk/blob/main/api.md) | [Package NPM](https://www.npmjs.com/package/@julep/sdk)
+- **Python** [Référence SDK](https://github.com/julep-ai/python-sdk/blob/main/api.md) | [Package PyPI](https://pypi.org/project/julep/)
+
+### 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](https://dev.julep.ai/api/docs#tag/agents)
+- [API des tâches](https://dev.julep.ai/api/docs#tag/tasks)
+- [API d'exécution](https://dev.julep.ai/api/docs#tag/executions)
+
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
 ## Démarrage rapide local
 
 **Exigences**:
@@ -1257,22 +1526,19 @@ results = client.agents.docs.search(
 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`
 
-## Référence du SDK
-
-- [Kit de développement logiciel Node.js](https://github.com/julep-ai/node-sdk/blob/main/api.md)
-- [SDK Python](https://github.com/julep-ai/python-sdk/blob/main/api.md)
-
-## Référence API
-
-Explorez notre documentation API complète pour en savoir plus sur les agents, les tâches et les exécutions :
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-- [API des agents](https://api.julep.ai/api/docs#tag/agents)
-- [API des tâches](https://api.julep.ai/api/docs#tag/tasks)
-- [API d'exécution](https://api.julep.ai/api/docs#tag/executions)
 
 *****
 
-## Pourquoi Julep vs. LangChain ?
+## Quelle est la différence entre Julep et LangChain etc ?
 
 ### Différents cas d'utilisation
 
@@ -1310,5 +1576,8 @@ Choisissez Julep lorsque vous avez besoin d'un framework robuste pour les agents
 <div align="center">
     <a href="#top">
         <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
     </a>
 </div>
diff --git a/README-JA.md b/README-JA.md
index 546500c54..a9aebe72a 100644
--- a/README-JA.md
+++ b/README-JA.md
@@ -6,7 +6,7 @@
 
 <p align="center">
   <br />
-  <a href="https://docs.julep.ai" rel="dofollow"><strong>ドキュメントを見る</strong></a>
+  <a href="https://docs.julep.ai" rel="dofollow">ドキュメントを見る</a>
   ·
   <a href="https://discord.com/invite/JTSBGRZrzj" rel="dofollow">不和</a>
   ·
@@ -62,42 +62,39 @@ Julep プロジェクトに新しい貢献者を迎えられることを嬉し
 
 <!-- START doctoc generated TOC please keep comment here to allow auto update -->
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
-<h3>📖 Table of Contents</h3>
-
-- [主な特徴](#%E4%B8%BB%E3%81%AA%E7%89%B9%E5%BE%B4)
-- [簡単な例](#%E7%B0%A1%E5%8D%98%E3%81%AA%E4%BE%8B)
-- [インストール](#%E3%82%A4%E3%83%B3%E3%82%B9%E3%83%88%E3%83%BC%E3%83%AB)
-- [Python クイックスタート 🐍](#python-%E3%82%AF%E3%82%A4%E3%83%83%E3%82%AF%E3%82%B9%E3%82%BF%E3%83%BC%E3%83%88-)
-  - [ステップ 1: エージェントを作成する](#%E3%82%B9%E3%83%86%E3%83%83%E3%83%97-1-%E3%82%A8%E3%83%BC%E3%82%B8%E3%82%A7%E3%83%B3%E3%83%88%E3%82%92%E4%BD%9C%E6%88%90%E3%81%99%E3%82%8B)
-  - [ステップ2: ストーリーと漫画を生成するタスクを作成する](#%E3%82%B9%E3%83%86%E3%83%83%E3%83%972-%E3%82%B9%E3%83%88%E3%83%BC%E3%83%AA%E3%83%BC%E3%81%A8%E6%BC%AB%E7%94%BB%E3%82%92%E7%94%9F%E6%88%90%E3%81%99%E3%82%8B%E3%82%BF%E3%82%B9%E3%82%AF%E3%82%92%E4%BD%9C%E6%88%90%E3%81%99%E3%82%8B)
-  - [ステップ3: タスクを実行する](#%E3%82%B9%E3%83%86%E3%83%83%E3%83%973-%E3%82%BF%E3%82%B9%E3%82%AF%E3%82%92%E5%AE%9F%E8%A1%8C%E3%81%99%E3%82%8B)
-  - [ステップ4: エージェントとチャットする](#%E3%82%B9%E3%83%86%E3%83%83%E3%83%974-%E3%82%A8%E3%83%BC%E3%82%B8%E3%82%A7%E3%83%B3%E3%83%88%E3%81%A8%E3%83%81%E3%83%A3%E3%83%83%E3%83%88%E3%81%99%E3%82%8B)
-- [Node.js クイックスタート 🟩](#nodejs-%E3%82%AF%E3%82%A4%E3%83%83%E3%82%AF%E3%82%B9%E3%82%BF%E3%83%BC%E3%83%88-)
-  - [ステップ 1: エージェントを作成する](#%E3%82%B9%E3%83%86%E3%83%83%E3%83%97-1-%E3%82%A8%E3%83%BC%E3%82%B8%E3%82%A7%E3%83%B3%E3%83%88%E3%82%92%E4%BD%9C%E6%88%90%E3%81%99%E3%82%8B-1)
-  - [ステップ2: ストーリーと漫画を生成するタスクを作成する](#%E3%82%B9%E3%83%86%E3%83%83%E3%83%972-%E3%82%B9%E3%83%88%E3%83%BC%E3%83%AA%E3%83%BC%E3%81%A8%E6%BC%AB%E7%94%BB%E3%82%92%E7%94%9F%E6%88%90%E3%81%99%E3%82%8B%E3%82%BF%E3%82%B9%E3%82%AF%E3%82%92%E4%BD%9C%E6%88%90%E3%81%99%E3%82%8B-1)
-  - [ステップ3: タスクを実行する](#%E3%82%B9%E3%83%86%E3%83%83%E3%83%973-%E3%82%BF%E3%82%B9%E3%82%AF%E3%82%92%E5%AE%9F%E8%A1%8C%E3%81%99%E3%82%8B-1)
-  - [ステップ4: エージェントとチャットする](#%E3%82%B9%E3%83%86%E3%83%83%E3%83%974-%E3%82%A8%E3%83%BC%E3%82%B8%E3%82%A7%E3%83%B3%E3%83%88%E3%81%A8%E3%83%81%E3%83%A3%E3%83%83%E3%83%88%E3%81%99%E3%82%8B-1)
-- [コンポーネント](#%E3%82%B3%E3%83%B3%E3%83%9D%E3%83%BC%E3%83%8D%E3%83%B3%E3%83%88)
-  - [メンタルモデル](#%E3%83%A1%E3%83%B3%E3%82%BF%E3%83%AB%E3%83%A2%E3%83%87%E3%83%AB)
-- [コンセプト](#%E3%82%B3%E3%83%B3%E3%82%BB%E3%83%97%E3%83%88)
-- [タスクを理解する](#%E3%82%BF%E3%82%B9%E3%82%AF%E3%82%92%E7%90%86%E8%A7%A3%E3%81%99%E3%82%8B)
-  - [ワークフローステップの種類](#%E3%83%AF%E3%83%BC%E3%82%AF%E3%83%95%E3%83%AD%E3%83%BC%E3%82%B9%E3%83%86%E3%83%83%E3%83%97%E3%81%AE%E7%A8%AE%E9%A1%9E)
-- [ツールの種類](#%E3%83%84%E3%83%BC%E3%83%AB%E3%81%AE%E7%A8%AE%E9%A1%9E)
-  - [ユーザー定義の `functions`](#%E3%83%A6%E3%83%BC%E3%82%B6%E3%83%BC%E5%AE%9A%E7%BE%A9%E3%81%AE-functions)
-  - [`システム` ツール](#%E3%82%B7%E3%82%B9%E3%83%86%E3%83%A0-%E3%83%84%E3%83%BC%E3%83%AB)
-  - [組み込みの `integrations`](#%E7%B5%84%E3%81%BF%E8%BE%BC%E3%81%BF%E3%81%AE-integrations)
-  - [直接の `api_calls`](#%E7%9B%B4%E6%8E%A5%E3%81%AE-api_calls)
-- [統合](#%E7%B5%B1%E5%90%88)
-- [その他の機能](#%E3%81%9D%E3%81%AE%E4%BB%96%E3%81%AE%E6%A9%9F%E8%83%BD)
-  - [エージェントへのツールの追加](#%E3%82%A8%E3%83%BC%E3%82%B8%E3%82%A7%E3%83%B3%E3%83%88%E3%81%B8%E3%81%AE%E3%83%84%E3%83%BC%E3%83%AB%E3%81%AE%E8%BF%BD%E5%8A%A0)
-  - [セッションとユーザーの管理](#%E3%82%BB%E3%83%83%E3%82%B7%E3%83%A7%E3%83%B3%E3%81%A8%E3%83%A6%E3%83%BC%E3%82%B6%E3%83%BC%E3%81%AE%E7%AE%A1%E7%90%86)
-  - [ドキュメントの統合と検索](#%E3%83%89%E3%82%AD%E3%83%A5%E3%83%A1%E3%83%B3%E3%83%88%E3%81%AE%E7%B5%B1%E5%90%88%E3%81%A8%E6%A4%9C%E7%B4%A2)
-- [ローカルクイックスタート](#%E3%83%AD%E3%83%BC%E3%82%AB%E3%83%AB%E3%82%AF%E3%82%A4%E3%83%83%E3%82%AF%E3%82%B9%E3%82%BF%E3%83%BC%E3%83%88)
-- [SDK リファレンス](#sdk-%E3%83%AA%E3%83%95%E3%82%A1%E3%83%AC%E3%83%B3%E3%82%B9)
-- [APIリファレンス](#api%E3%83%AA%E3%83%95%E3%82%A1%E3%83%AC%E3%83%B3%E3%82%B9)
-- [Julep と LangChain を比較する理由](#julep-%E3%81%A8-langchain-%E3%82%92%E6%AF%94%E8%BC%83%E3%81%99%E3%82%8B%E7%90%86%E7%94%B1)
-  - [さまざまなユースケース](#%E3%81%95%E3%81%BE%E3%81%96%E3%81%BE%E3%81%AA%E3%83%A6%E3%83%BC%E3%82%B9%E3%82%B1%E3%83%BC%E3%82%B9)
-  - [異なるフォームファクタ](#%E7%95%B0%E3%81%AA%E3%82%8B%E3%83%95%E3%82%A9%E3%83%BC%E3%83%A0%E3%83%95%E3%82%A1%E3%82%AF%E3%82%BF)
+<h3>📖 目次</h3>
+
+- [はじめに](#introduction)
+- [主な特徴](#key-features)
+- [簡単な例](#quick-example)
+- [インストール](#installation)
+- [Python クイックスタート 🐍](#python-quick-start-)
+- [Node.js クイック スタート 🟩](#nodejs-quick-start-)
+- [ステップ 1: エージェントを作成する](#step-1-create-an-agent)
+- [コンポーネント](#components)
+- [メンタルモデル](#mental-model)
+- [コンセプト](#concepts)
+- [タスクの理解](#understanding-tasks)
+- [タスクのライフサイクル](#lifecycle-of-a-task)
+- [ワークフロー ステップの種類](#types-of-workflow-steps)
+- [ツールの種類](#tool-types)
+- [ユーザー定義の `functions`](#user-defined-functions)
+- [`システム` ツール](#system-tools)
+- [組み込みの `integrations`](#built-in-integrations)
+- [直接の `api_calls`](#direct-api_calls)
+- [統合](#integrations)
+- [その他の機能](#other-features)
+- [エージェントへのツールの追加](#adding-tools-to-agents)
+- [セッションとユーザーの管理](#managing-sessions-and-users)
+- [ドキュメントの統合と検索](#document-integration-and-search)
+- [参考](#reference)
+- [SDKリファレンス](#sdk-reference)
+- [APIリファレンス](#api-reference)
+- [ローカルクイックスタート](#local-quickstart)
+- [Julep と LangChain などの違いは何ですか?](#whats-the-difference-between-julep-and-langchain-etc)
+- [さまざまなユースケース](#different-use-cases)
+- [異なるフォームファクター](#different-form-factor)
+- [要約](#in-summary)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
@@ -107,40 +104,46 @@ Julep は、過去のやり取りを記憶し、複雑なタスクを実行で
 
 Julep を使用すると、意思決定、ループ、並列処理、多数の外部ツールや API との統合を組み込んだ複数ステップのタスクを作成できます。
 
-多くの AI アプリケーションは、分岐が最小限の、プロンプトと API 呼び出しの単純な線形チェーンに制限されていますが、Julep はより複雑なシナリオを処理できるように構築されています。
+多くの AI アプリケーションは、最小限の分岐によるプロンプトと API 呼び出しの単純な線形チェーンに制限されていますが、Julep は次のようなより複雑なシナリオを処理できるように構築されています。
 
-サポート対象:
-
-- 複雑で多段階のプロセス
-- ダイナミックな意思決定
-- 並列実行
+- 複数のステップがある、
+- モデルの出力に基づいて意思決定を行う
+- 平行枝を生成し、
+- たくさんのツールを使い、
+- 長時間走る。
 
 > [!ヒント]
-> 単純な質問に答えるだけでなく、複雑なタスクを処理し、過去のやり取りを記憶し、場合によっては他のツールや API も使用できる AI エージェントを構築したいとします。そこで Julep の出番です。
+> 単純な質問に答えるだけでなく、複雑なタスクを処理し、過去のやり取りを記憶し、場合によっては他のツールや API も使用できる AI エージェントを構築したいとします。そこで Julep の出番です。詳細については、[タスクの理解](#understanding-tasks) をお読みください。
 
 ## 主な特徴
 
 1. 🧠 **永続的な AI エージェント**: 長期にわたるやり取りを通じてコン​​テキストと情報を記憶します。
 2. 💾 **ステートフル セッション**: 過去のやり取りを追跡して、パーソナライズされた応答を提供します。
-3. 🔄 **複数ステップのタスク**: ループと意思決定を使用して、複雑な複数ステップのプロセスを構築します。
+3. 🔄 **複数ステップのタスク**: ループと意思決定を含む複雑な複数ステップのプロセスを構築します。
 4. ⏳ **タスク管理**: 無期限に実行される可能性のある長時間実行タスクを処理します。
 5. 🛠️ **組み込みツール**: タスクで組み込みツールと外部 API を使用します。
 6. 🔧 **自己修復**: Julep は失敗したステップを自動的に再試行し、メッセージを再送信し、一般的にタスクがスムーズに実行されるようにします。
 7. 📚 **RAG**: Julep のドキュメント ストアを使用して、独自のデータを取得して使用するためのシステムを構築します。
 
-Julep は、単純なプロンプト応答モデルを超えた AI ユースケースを必要とするアプリケーションに最適です。
+![機能](https://github.com/user-attachments/assets/4355cbae-fcbd-4510-ac0d-f8f77b73af70)
+
+> [!ヒント]
+> Julep は、単純なプロンプト応答モデルを超えた AI ユースケースを必要とするアプリケーションに最適です。
 
 ## 簡単な例
 
 次のことができる研究 AI エージェントを想像してください。
 
-1. トピックを取り上げ、
-2. そのトピックについて100個の検索クエリを考えます。
+1. **トピックを選ぶ**、
+2. そのトピックについて**100個の検索クエリを考え出す**
 3. ウェブ検索を並行して実行する
-4. 結果をまとめる
-5.要約をDiscordに送信する
+4. 結果を**要約**します。
+5. **要約を Discord に送信**します。
 
-Julepでは、これは単一のタスクになります<b>80行のコード</b>そして走る<b>完全に管理された</b>すべては Julep のサーバー上で実行されます。すべての手順は Julep のサーバー上で実行されるため、何もする必要はありません。次に動作例を示します。
+> [!注意]
+> Julepでは、これは単一のタスクになります<b>80行のコード</b>そして走る<b>完全に管理された</b>すべて自動的に行われます。すべての手順は Julep の独自のサーバー上で実行されるため、何もする必要はありません。
+
+実際の例を次に示します。
 
 ```yaml
 name: Research Agent
@@ -160,12 +163,12 @@ tools:
     integration:
       provider: brave
       setup:
-        api_key: "YOUR_BRAVE_API_KEY"
+        api_key: BSAqES7dj9d...  # dummy key
 
   - name: discord_webhook
     type: api_call
     api_call:
-      url: "YOUR_DISCORD_WEBHOOK_URL"
+      url: https://eobuxj02se0n.m.pipedream.net  # dummy requestbin
       method: POST
       headers:
         Content-Type: application/json
@@ -197,7 +200,7 @@ main:
       tool: web_search
       arguments:
         query: "_"
-    parallelism: 100
+    parallelism: 10
 
   # Collect the results from the web search
   - evaluate:
@@ -211,28 +214,74 @@ main:
           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: >
-        **Research Summary for {{inputs[0].topic}}**
+      content: |-
+        f'''
+        **Research Summary for {inputs[0].topic}**
 
-        {{_}}
+        {_}
+        '''
 ```
 
 この例では、Julep は並列実行を自動的に管理し、失敗したステップを再試行し、API リクエストを再送信し、タスクが完了するまで確実に実行し続けます。
 
+> これは 30 秒以内に実行され、次の出力を返します。
+
+<details>
+<summary><b>AIに関する研究概要</b> <i>（クリックして拡大）</i></summary>
+
+> **AIに関する研究概要**
+> 
+> ### 人工知能（AI）に関する研究成果の概要
+> 
+> #### はじめに
+> 人工知能 (AI) の分野は近年、機械が環境を認識し、データから学習し、意思決定を行える方法とテクノロジーの開発により、大きな進歩を遂げています。この概要では、AI に関連するさまざまな研究結果から得られた洞察に主に焦点を当てています。
+> 
+> #### 主な調査結果
+> 
+> 1. **AIの定義と範囲**:
+> - AI は、学習、推論、問題解決など、人間のような知能を必要とするタスクを実行できるシステムの作成に重点を置いたコンピューター サイエンスの分野として定義されています (Wikipedia)。
+> - 機械学習、自然言語処理、ロボット工学、コンピュータービジョンなど、さまざまなサブフィールドを網羅しています。
+> 
+> 2. **影響と応用**:
+> - AI テクノロジーはさまざまな分野に統合され、効率性と生産性を向上させています。その応用範囲は、自律走行車やヘルスケア診断から顧客サービスの自動化や財務予測まで多岐にわたります (OpenAI)。
+> - AI をすべての人にとって有益なものにするという Google の取り組みは、さまざまなプラットフォームでユーザー エクスペリエンスを強化することで日常生活を大幅に改善する可能性を強調しています (Google AI)。
+> 
+> 3. **倫理的配慮**:
+> - プライバシー、偏見、意思決定プロセスの説明責任に関する懸念など、AI の倫理的影響に関する議論が続いています。AI 技術の安全で責任ある使用を保証するフレームワークの必要性が強調されています (OpenAI)。
+> 
+> 4. **学習メカニズム**:
+> - AI システムは、教師あり学習、教師なし学習、強化学習などのさまざまな学習メカニズムを活用します。これらの方法により、AI は過去の経験やデータから学習することで、時間の経過とともにパフォーマンスを向上させることができます (Wikipedia)。
+> - 教師あり学習と教師なし学習の区別は重要です。教師あり学習はラベル付きデータに依存しますが、教師なし学習は事前定義されたラベルなしでパターンを識別します (教師なし)。
+> 
+> 5. **今後の方向性**:
+> - 今後の AI 開発では、AI システムの解釈可能性と透明性を高め、正当な判断と行動を提供できるようにすることに重点が置かれると予想されます (OpenAI)。
+> - AI システムをよりアクセスしやすく、ユーザーフレンドリーなものにし、さまざまな人口統計や業界での幅広い導入を促進する動きもあります (Google AI)。
+> 
+> #### 結論
+> AI は複数の領域に変革をもたらす力を持ち、産業の再構築や生活の質の向上が期待されています。しかし、AI の機能が拡大するにつれて、倫理的および社会的影響に対処することが極めて重要になります。AI の将来像を見据えるには、技術者、倫理学者、政策立案者による継続的な研究と協力が不可欠です。
+
+</details>
+
 ## インストール
 
 Julep を使い始めるには、[npm](https://www.npmjs.com/package/@julep/sdk) または [pip](https://pypi.org/project/julep/) を使用してインストールします。
 
+**Node.js**:
 ```bash
 npm install @julep/sdk
-```
 
-または
+# or
 
+bun add @julep/sdk
+```
+
+**Python**:
 ```bash
 pip install julep
 ```
@@ -249,997 +298,1219 @@ pip install julep
 
 ## Python クイックスタート 🐍
 
-### ステップ 1: エージェントを作成する
-
 ```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="gpt-4o",
-    about="You are a creative storytelling agent that can craft engaging stories and generate comic panels based on ideas.",
+    model="claude-3.5-sonnet",
+    about="You are a creative storyteller that crafts engaging stories on a myriad of topics.",
 )
 
-# 🛠️ Add an image generation tool (DALL·E) to the agent
-client.agents.tools.create(
-    agent_id=agent.id,
-    name="image_generator",
-    description="Use this tool to generate images based on descriptions.",
-    integration={
-        "provider": "dalle",
-        "method": "generate_image",
-        "setup": {
-            "api_key": "your_openai_api_key",
-        },
-    },
-)
-```
-
-### ステップ2: ストーリーと漫画を生成するタスクを作成する
-
-入力されたアイデアに基づいてストーリーを作成し、パネル化された漫画を生成するためのマルチステップタスクを定義しましょう。
+### Step 2: Create a Task that generates a story and comic strip
 
-```python
-# 📋 Task
-# Create a task that takes an idea and creates a story and a 4-panel comic strip
 task_yaml = """
-name: Story and Comic Creator
-description: Create a story based on an idea and generate a 4-panel comic strip illustrating the story.
+name: Storyteller
+description: Create a story based on an idea.
+
+tools:
+  - name: research_wikipedia
+    integration:
+      provider: wikipedia
+      method: search
 
 main:
-  # Step 1: Generate a story and outline into 4 panels
+  # Step 1: Generate plot idea
   - prompt:
       - role: system
         content: You are {{agent.name}}. {{agent.about}}
       - role: user
         content: >
-          Based on the idea '{{_.idea}}', write a short story suitable for a 4-panel comic strip.
-          Provide the story and a numbered list of 4 brief descriptions for each panel illustrating key moments in the story.
+          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 ```応答の最後に yaml タグを追加します。
+アンラップ: true
+
+- 評価する：
+plot_ideas: load_yaml(_.split('```yaml')[1].split('```')[0].ストリップ())
+
+# ステップ2: プロットのアイデアから研究分野を抽出する
+- プロンプト：
+- 役割: システム
+内容: あなたは {{agent.name}} です。 {{agent.about}}
+- 役割: ユーザー
+内容: >
+ストーリーのプロットのアイデアをいくつか紹介します。
+{% for idea in _.plot_ideas %}
+- {{アイデア}}
+{% endfor %}
+
+ストーリーを展開するには、プロットのアイデアをリサーチする必要があります。
+何を研究すべきでしょうか? 興味深いと思うプロットのアイデアについて、Wikipedia の検索クエリを書き留めてください。
+出力をyamlリストとして返します```yaml tags at the end of your response.
     unwrap: true
+    settings:
+      model: gpt-4o-mini
+      temperature: 0.7
 
-  # Step 2: Extract the panel descriptions and story
   - evaluate:
-      story: _.split('1. ')[0].strip()
-      panels: re.findall(r'\\d+\\.\\s*(.*?)(?=\\d+\\.\\s*|$)', _)
+      research_queries: load_yaml(_.split('```yaml')[1].split('```')[0].strip())
 
-  # Step 3: Generate images for each panel using the image generator tool
+  # Step 3: Research each plot idea
   - foreach:
-      in: _.panels
+      in: _.research_queries
       do:
-        tool: image_generator
+        tool: research_wikipedia
         arguments:
-          description: _
+          query: _
+
+  - evaluate:
+      wikipedia_results: 'NEWLINE.join([f"- {doc.metadata.title}: {doc.metadata.summary}" for item in _ for doc in item.documents])'
 
-  # Step 4: Generate a catchy title for the story
+  # Step 4: Think and deliberate
   - prompt:
       - role: system
         content: You are {{agent.name}}. {{agent.about}}
       - role: user
-        content: >
-          Based on the story below, generate a catchy title.
-
-          Story: {{outputs[1].story}}
-    unwrap: true
-
-  # Step 5: Return the story, the generated images, and the title
-  - return:
-      title: outputs[3]
-      story: outputs[1].story
-      comic_panels: "[output.image.url for output in outputs[2]]"
+        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 ```応答の最後に yaml タグを追加します。yaml オブジェクトの構造は次のようになります。
+
+          ```yaml
+          title: "<string>"
+          characters:
+          - name: "<string>"
+            about: "<string>"
+          synopsis: "<string>"
+          scenes:
+          - title: "<string>"
+            description: "<string>"
+            characters:
+            - name: "<string>"
+              role: "<string>"
+            plotlines:
+            - "<string>"```
+
+yaml が有効であり、文字とシーンが空でないことを確認してください。また、セミコロンや yaml の記述に関するその他の注意点にも注意してください。
+アンラップ: true
+
+- 評価する：
+プロット: "load_yaml(_.split('```yaml')[1].split('```')[0].strip())"
 """
 
-task = client.tasks.create(
-    agent_id=agent.id,
-    **yaml.safe_load(task_yaml)
+タスク = client.tasks.create(
+エージェントID=エージェントID、
+**yaml.safe_load(タスクyaml)
 )
-```
 
 ### ステップ3: タスクを実行する
 
-```python
-# 🚀 Execute the task with an input idea
-execution = client.executions.create(
-    task_id=task.id,
-    input={"idea": "A cat who learns to fly"}
+実行 = client.executions.create(
+タスクID=タスクID、
+input={"idea": "飛ぶことを学ぶ猫"}
 )
 
-# 🎉 Watch as the story and comic panels are generated
-for transition in client.executions.transitions.stream(execution_id=execution.id):
-    print(transition)
+# 🎉 ストーリーと漫画パネルが生成される様子をご覧ください
+while (result := client.executions.get(execution.id)).status が ['succeeded', 'failed'] の範囲外です:
+print(結果.ステータス、結果.出力)
+時間.睡眠(1)
 
-# 📦 Once the execution is finished, retrieve the results
-result = client.executions.get(execution_id=execution.id)
+# 📦 実行が完了したら、結果を取得します
+result.status == "成功"の場合:
+print(結果.出力)
+それ以外：
+例外(結果.エラー)を発生させる
 ```
 
-### ステップ4: エージェントとチャットする
-
-エージェントとの対話型チャット セッションを開始します。
+You can find the full python example [here](example.py).
 
-```python
-session = client.sessions.create(agent_id=agent.id)
-
-# 💬 Send messages to the agent
-while (message := input("Enter a message: ")) != "quit":
-    response = client.sessions.chat(
-        session_id=session.id,
-        message=message,
-    )
-
-    print(response)
-```
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-完全な Python の例は [ここ](example.py) にあります。
+## Node.js Quick Start 🟩
 
-## Node.js クイックスタート 🟩
+### Step 1: Create an Agent
 
-### ステップ 1: エージェントを作成する
+```ジャバスクリプト
+// ステップ 0: セットアップ
+定数dotenv = require('dotenv');
+Julep のクラスを '@julep/sdk' として定義します。
+yaml を require('yaml');
 
-```javascript
-import { Julep } from "@julep/sdk";
-import yaml from "js-yaml";
+config() を呼び出します。
 
-const client = new Julep({ apiKey: "your_julep_api_key" });
+const client = new Julep({ apiKey: process.env.JULEP_API_KEY, 環境: process.env.JULEP_ENVIRONMENT || "production" });
 
-async function createAgent() {
-  const agent = await client.agents.create({
-    name: "Storytelling Agent",
-    model: "gpt-4",
-    about:
-      "You are a creative storytelling agent that can craft engaging stories and generate comic panels based on ideas.",
-  });
+/* ステップ 1: エージェントを作成する */
 
-  // 🛠️ Add an image generation tool (DALL·E) to the agent
-  await client.agents.tools.create(agent.id, {
-    name: "image_generator",
-    description: "Use this tool to generate images based on descriptions.",
-    integration: {
-      provider: "dalle",
-      method: "generate_image",
-      setup: {
-        api_key: "your_openai_api_key",
-      },
-    },
+非同期関数createAgent() {
+const エージェント = クライアント.エージェント.作成を待機します({
+名前: 「ストーリーテリングエージェント」
+モデル: "claude-3.5-sonnet",
+概要: 「あなたは、さまざまなトピックについて魅力的なストーリーを作り上げることができるクリエイティブなストーリーテラーです。」
   });
-
-  return agent;
+返品エージェント;
 }
-```
 
-### ステップ2: ストーリーと漫画を生成するタスクを作成する
-
-```javascript
-const taskYaml = `
-name: Story and Comic Creator
-description: Create a story based on an idea and generate a 4-panel comic strip illustrating the story.
-
-main:
-  # Step 1: Generate a story and outline into 4 panels
-  - prompt:
-      - role: system
-        content: You are {{agent.name}}. {{agent.about}}
-      - role: user
-        content: >
-          Based on the idea '{{_.idea}}', write a short story suitable for a 4-panel comic strip.
-          Provide the story and a numbered list of 4 brief descriptions for each panel illustrating key moments in the story.
-    unwrap: true
-
-  # Step 2: Extract the panel descriptions and story
-  - evaluate:
-      story: _.split('1. ')[0].trim()
-      panels: _.match(/\\d+\\.\\s*(.*?)(?=\\d+\\.\\s*|$)/g)
-
-  # Step 3: Generate images for each panel using the image generator tool
-  - foreach:
-      in: _.panels
-      do:
-        tool: image_generator
-        arguments:
-          description: _
-
-  # Step 4: Generate a catchy title for the story
-  - prompt:
-      - role: system
-        content: You are {{agent.name}}. {{agent.about}}
-      - role: user
-        content: >
-          Based on the story below, generate a catchy title.
-
-          Story: {{outputs[1].story}}
-    unwrap: true
-
-  # Step 5: Return the story, the generated images, and the title
-  - return:
-      title: outputs[3]
-      story: outputs[1].story
-      comic_panels: outputs[2].map(output => output.image.url)
+/* ステップ 2: ストーリーと漫画を生成するタスクを作成する */
+
+const タスクYaml = `
+名前: ストーリーテラー
+説明: アイデアに基づいてストーリーを作成します。
+
+ツール:
+- 名前: research_wikipedia
+統合：
+提供元: wikipedia
+方法: 検索
+
+主要：
+# ステップ1: プロットのアイデアを生み出す
+- プロンプト：
+- 役割: システム
+内容: あなたは {{agent.name}} です。 {{agent.about}}
+- 役割: ユーザー
+内容: >
+アイデア「{{_.idea}}」に基づいて、5 つのプロット アイデアのリストを生成します。自由に創造的に考えてください。出力は、応答の最後に \`\`\`yaml タグ内の長い文字列のリストとして返されます。
+アンラップ: true
+
+- 評価する：
+plot_ideas: load_yaml(_.split('\`\`\`yaml')[1].split('\`\`\`')[0].strip())
+
+# ステップ2: プロットのアイデアから研究分野を抽出する
+- プロンプト：
+- 役割: システム
+内容: あなたは {{agent.name}} です。 {{agent.about}}
+- 役割: ユーザー
+内容: >
+ストーリーのプロットのアイデアをいくつか紹介します。
+{% for idea in _.plot_ideas %}
+- {{アイデア}}
+{% endfor %}
+
+ストーリーを展開するには、プロットのアイデアをリサーチする必要があります。
+何を研究すべきでしょうか? 興味深いと思うプロットのアイデアについて、Wikipedia の検索クエリを書き留めてください。
+応答の最後に、\`\`\`yaml タグ内の yaml リストとして出力を返します。
+アンラップ: true
+設定：
+モデル: gpt-4o-mini
+温度: 0.7
+
+- 評価する：
+リサーチクエリ: load_yaml(_.split('\`\`\`yaml')[1].split('\`\`\`')[0].strip())
+
+# ステップ3: 各プロットのアイデアをリサーチする
+- 各:
+in: _.research_queries
+する：
+ツール: research_wikipedia
+引数:
+クエリ: _
+
+- 評価する：
+wikipedia_results: 'NEWLINE.join([f"- {doc.metadata.title}: {doc.metadata.summary}" for item in _ for doc in item.documents])'
+
+# ステップ4: 考えて熟考する
+- プロンプト：
+- 役割: システム
+内容: あなたは {{agent.name}} です。 {{agent.about}}
+- 役割: ユーザー
+内容: |-
+物語を書く前に、考え、熟考してみましょう。ここにいくつかのプロットのアイデアがあります:
+{% 出力[1].plot_ideas のアイデア %}
+- {{アイデア}}
+{% endfor %}
+
+Wikipedia でプロットのアイデアを調査した結果は次のとおりです。
+{{_.wikipedia_results}}
+
+プロットのアイデアを批判的に考えます。プロットのアイデアと Wikipedia の結果を組み合わせて、ストーリーの詳細なプロットを作成します。
+メモや考えをすべて書き留めてください。
+最後に、レスポンスの最後にある \`\`\`yaml タグ内に yaml オブジェクトとしてプロットを記述します。yaml オブジェクトの構造は次のようになります。
+
+\`\`\`yaml
+タイトル： "<string>"
+文字:
+- 名前： "<string>"
+について： "<string>"
+概要: "<string>"
+シーン:
+- タイトル： "<string>"
+説明： "<string>"
+文字:
+- 名前： "<string>"
+役割： "<string>"
+ストーリーライン:
+            - "<string>「\`\`\`
+
+yaml が有効であり、文字とシーンが空でないことを確認してください。また、セミコロンや yaml の記述に関するその他の注意点にも注意してください。
+アンラップ: true
+
+- 評価する：
+プロット: "load_yaml(_.split('\`\`\`yaml')[1].split('\`\`\`')[0].strip())"
 `;
 
-async function createTask(agent) {
-  const task = await client.tasks.create(agent.id, yaml.load(taskYaml));
-  return task;
-}
-```
-
-### ステップ3: タスクを実行する
-
-```javascript
-async function executeTask(task) {
-  const execution = await client.executions.create(task.id, {
-    input: { idea: "A cat who learns to fly" },
-  });
-
-  // 🎉 Watch as the story and comic panels are generated
-  for await (const transition of client.executions.transitions.stream(
-    execution.id
-  )) {
-    console.log(transition);
-  }
-
-  // 📦 Once the execution is finished, retrieve the results
-  const result = await client.executions.get(execution.id);
-  return result;
+非同期関数createTask(agentId) {
+const タスク = クライアント.タスク.作成を待機します(
+エージェントID、
+yaml.parse(タスクYaml)
+  );
+タスクを返す。
 }
-```
 
-### ステップ4: エージェントとチャットする
+/* ステップ 3: タスクを実行する */
 
-```javascript
-async function chatWithAgent(agent) {
-  const session = await client.sessions.create({ agent_id: agent.id });
-
-  // 💬 Send messages to the agent
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
+非同期関数executeTask(taskId) {
+const 実行 = クライアント.実行.作成(taskId, {
+入力: { アイデア: 「飛ぶことを学ぶ猫」 }
   });
 
-  const chat = async () => {
-    rl.question("Enter a message (or 'quit' to exit): ", async (message) => {
-      if (message.toLowerCase() === "quit") {
-        rl.close();
-        return;
+// 🎉 ストーリーと漫画パネルが生成される様子をご覧ください
+（真）の間{
+const 結果 = client.executions.get(execution.id); を待機します。
+console.log(結果のステータス、結果の出力);
+
+if (result.status === '成功' || result.status === '失敗') {
+// 📦 実行が終了したら、結果を取得します
+if (result.status === "成功") {
+console.log(結果の出力);
+} それ以外 {
+新しいエラーをスローします(result.error);
       }
+壊す;
+    }
 
-      const response = await client.sessions.chat(session.id, { message });
-      console.log(response);
-      chat();
-    });
-  };
-
-  chat();
+新しい Promise(resolve => setTimeout(resolve, 1000)) を待機します。
+  }
 }
 
-// Run the example
-async function runExample() {
-  const agent = await createAgent();
-  const task = await createTask(agent);
-  const result = await executeTask(task);
-  console.log("Task Result:", result);
-  await chatWithAgent(agent);
+// 例を実行するためのメイン関数
+非同期関数main() {
+試す {
+const エージェント = createAgent() を待機します。
+const タスク = createTask(agent.id);
+タスクの実行を待機します(task.id);
+} キャッチ（エラー）{
+console.error("エラーが発生しました:", error);
+  }
 }
 
-runExample().catch(console.error);
+main().then(() => console.log("完了")).catch(console.error);
 ```
 
-完全な Node.js の例は [ここ](example.js) にあります。
+You can find the full Node.js example [here](example.js).
 
-## コンポーネント
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
+## Components
 
-Julep は次のコンポーネントで構成されています。
+Julep is made up of the following components:
 
-- **Julep プラットフォーム**: Julep プラットフォームは、ワークフローを実行するクラウド サービスです。ワークフローを記述するための言語、ワークフローを実行するためのサーバー、プラットフォームと対話するための SDK が含まれています。
-- **Julep SDK**: Julep SDK は、ワークフローを構築するためのライブラリのセットです。Python 用と JavaScript 用の SDK があり、今後さらに追加される予定です。
-- **Julep API**: Julep API は、Julep プラットフォームと対話するために使用できる RESTful API です。
+- **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
 
 <div align="center">
   <img src="https://github.com/user-attachments/assets/38420b5d-9342-4c8d-bae9-b47c28ae45af" height="360" />
 </div>
 
-Julep は、クライアント側とサーバー側の両方のコンポーネントを組み合わせて、高度な AI エージェントの構築を支援するプラットフォームと考えてください。これを視覚化する方法は次のとおりです。
+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. **アプリケーションコード:**
+1. **Your Application Code:**
 
-- アプリケーションで Julep SDK を使用して、エージェント、タスク、ワークフローを定義できます。
-- SDK は、これらのコンポーネントのセットアップと管理を容易にする関数とクラスを提供します。
+   - 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 バックエンド サービス:**
+2. **Julep Backend Service:**
 
-- SDK はネットワーク経由で Julep バックエンドと通信します。
-- バックエンドは、タスクの実行を処理し、セッション状態を維持し、ドキュメントを保存し、ワークフローを調整します。
+   - 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. **ツールとAPIとの統合:**
-- ワークフロー内で、外部ツールやサービスを統合できます。
-- バックエンドはこれらの統合を容易にするため、エージェントは、たとえば、Web 検索を実行したり、データベースにアクセスしたり、サードパーティの API を呼び出したりすることができます。
+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.
 
-## コンセプト
+## Concepts
 
-Julep は、強力な AI ワークフローを作成するために連携するいくつかの主要な技術コンポーネントに基づいて構築されています。
+Julep is built on several key technical components that work together to create powerful AI workflows:
 
-```mermaid
-graph TD
-    User[User] ==> Session[Session]
-    Session --> Agent[Agent]
-    Agent --> Tasks[Tasks]
-    Agent --> LLM[Large Language Model]
-    Tasks --> Tools[Tools]
-    Agent --> Documents[Documents]
-    Documents --> VectorDB[Vector Database]
-    Tasks --> Executions[Executions]
+```マーメイド
+グラフTD
+ユーザー[ユーザー] ==> セッション[セッション]
+セッション --> エージェント[エージェント]
+エージェント --> タスク[タスク]
+エージェント --> LLM[大規模言語モデル]
+タスク --> ツール[ツール]
+エージェント --> ドキュメント[ドキュメント]
+ドキュメント --> VectorDB[ベクターデータベース]
+タスク --> 実行[実行]
 
-    classDef client fill:#9ff,stroke:#333,stroke-width:1px;
-    class User client;
+classDef client fill:#9ff、stroke:#333、stroke-width:1px;
+クラス User クライアント;
 
-    classDef core fill:#f9f,stroke:#333,stroke-width:2px;
-    class Agent,Tasks,Session core;
+classDef core fill:#f9f、stroke:#333、stroke-width:2px;
+クラス Agent、Tasks、Session コア;
 ```
 
-- **エージェント**: タスクを実行し、ユーザーと対話する大規模言語モデル (LLM) を搭載した AI 搭載エンティティ。
-- **ユーザー**: セッションを通じてエージェントと対話するエンティティ。
-- **セッション**: エージェントとユーザー間のステートフルなやり取り。複数のやり取りにわたってコンテキストを維持します。
-- **タスク**: プロンプト、ツール呼び出し、条件付きロジックなどのさまざまな種類のステップを含む、エージェントが実行できる複数ステップのプログラム ワークフロー。
-- **ツール**: ユーザー定義関数、システム ツール、サードパーティ API 統合など、エージェントの機能を拡張する統合。
-- **ドキュメント**: エージェントまたはユーザーに関連付けられたテキストまたはデータ オブジェクト。セマンティック検索と取得のためにベクトル化され、保存されます。
-- **実行**: 特定の入力で開始され、独自のライフサイクルとステート マシンを持つタスクのインスタンス。
+- **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.
+
 
-より詳細な説明については、[コンセプトのドキュメント](https://github.com/julep-ai/julep/blob/dev/docs/julep-concepts.md)を参照してください。
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
+## 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:
 
-タスクは Julep のワークフロー システムの中核です。タスクを使用すると、エージェントが実行できる複雑な複数ステップの AI ワークフローを定義できます。タスク コンポーネントの概要は次のとおりです。
+- **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](#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:
 
-Julep のタスクにはさまざまな種類のステップを含めることができるため、複雑で強力なワークフローを作成できます。利用可能なステップの種類の概要は次のとおりです。
+```マーメイド
+シーケンス図
+参加者Dをあなたのコードとして
+参加者C（ジュレップクライアント）
+参加者Sはジュレップサーバーとして
 
-#### 一般的な手順
+D->>C: タスクの作成
+C->>S: 実行を送信
+Sの上のメモ: タスクの実行
+Sに関する注意: 状態の管理
+S-->>C: 実行イベント
+C-->>D: 進捗状況の更新
+S->>C: 実行完了
+C->>D: 最終結果
+```
+
+### 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
 
 <table>
 <tr>
-<td>名前</td> <td>について</td><td>構文</td>
+    <th>Name</th>
+    <th>About</th>
+    <th>Syntax</th>
 </tr>
 <tr>
-<td>プロンプト</td>
+<td> <b>Prompt</b> </td>
 <td>
-AIモデルにメッセージを送信し、応答を受け取る
-
+Send a message to the AI model and receive a response
+<br><br><b>Note:</b> The prompt step uses Jinja templates and you can access context variables in them.
 </td>
 
 <td>
 
-```yaml
-- prompt: "Analyze the following data: {{data}}"
+```ヤム
+- プロンプト: 「次のデータを分析してください: {{agent.name}}」 # <-- これは jinja テンプレートです
+```
+
+```ヤム
+- プロンプト：
+- 役割: システム
+内容: 「あなたは {{agent.name}} です。 {{agent.about}}」
+- 役割: ユーザー
+内容: 「次のデータを分析します: {{_.data}}」
 ```
 
 </td>
 </tr>
 <tr>
-<td>ツールコール</td>
+<td> <b>Tool Call</b> </td>
 <td>
-統合ツールまたはAPIを実行する
+Execute an integrated tool or API that you have previously declared in the task.
+<br><br><b>Note:</b> The tool call step uses Python expressions inside the arguments.
 
 </td>
 
 <td>
 
-```yaml
-- tool: web_search
-  arguments:
-    query: "Latest AI developments"
+```ヤム
+- ツール: web_search
+引数:
+クエリ: '"最新の AI 開発"' # <-- これは Python 式です (引用符に注意してください)
+num_results: len(_.topics) # <-- リストの長さにアクセスするための Python 式
 ```
 
 </td>
 </tr>
 <tr>
-<td>評価する</td>
+<td> <b>Evaluate</b> </td>
 <td>
-計算を実行したりデータを操作したりする
-
+Perform calculations or manipulate data
+<br><br><b>Note:</b> The evaluate step uses Python expressions.
 </td>
 
 <td>
 
-```yaml
-- evaluate:
-    average_score: "sum(scores) / len(scores)"
+```ヤム
+- 評価する：
+average_score: 合計(スコア) / 長さ(スコア)
 ```
 
 </td>
 </tr>
 <tr>
-<td>入力を待つ</td>
+<td> <b>Wait for Input</b> </td>
 <td>
-入力を受信するまでワークフローを一時停止する
+Pause workflow until input is received. It accepts an `info` field that can be used by your application to collect input from the user.
+
+<br><br><b>Note:</b> 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.
 
 </td>
 
 <td>
 
-```yaml
-- wait_for_input:
-    info:
-      message: "Please provide additional information."
+```ヤム
+- 入力待ち:
+情報：
+メッセージ: '"{_.required_info} に関する追加情報を提供してください。"' # <-- コンテキスト変数にアクセスするための Python 式
 ```
 
 </td>
 </tr>
 <tr>
-<td>ログ</td>
+<td> <b>Log</b> </td>
 <td>
-指定された値またはメッセージをログに記録する
+Log a specified value or message.
+
+<br><br><b>Note:</b> The log step uses Jinja templates and you can access context variables in them.
 
 </td>
 
 <td>
 
-```yaml
-- log: "Processing completed for item {{item_id}}"
+```ヤム
+- ログ: "アイテム {{_.item_id}} の処理が完了しました" # <-- コンテキスト変数にアクセスするための jinja テンプレート
 ```
 
 </td>
 </tr>
 </table>
 
-#### キー値ステップ
+#### Key-Value Steps
 
 <table>
 <tr>
-<td>名前</td> <td>について</td><td>構文</td>
+<th> Name </th> <th> About </th><th>Syntax</th>
 </tr>
 <tr>
-<td>得る</td>
+<td> <b>Get</b> </td>
 <td>
-キーバリューストアから値を取得する
+Retrieve a value from the execution's key-value store.
 
 </td>
 
 <td>
 
-```yaml
-- get: "user_preference"
+```ヤム
+- 取得: user_preference
 ```
 
 </td>
 </tr>
 <tr>
-<td>セット</td>
+<td> <b>Set</b> </td>
 <td>
-キーバリューストア内のキーに値を割り当てる
+Assign a value to a key in the execution's key-value store.
 
+<br><br><b>Note:</b> The set step uses Python expressions.
 </td>
 
 <td>
 
-```yaml
-- set:
-    user_preference: "dark_mode"
+```ヤム
+- セット：
+user_preference: '"dark_mode"' # <-- python 式
 ```
 
 </td>
 </tr>
 </table>
 
-#### 反復ステップ
+#### Iteration Steps
 
 <table>
 <tr>
-<td>名前</td> <td>について</td><td>構文</td>
+<th> Name </th> <th> About </th><th>Syntax</th>
 </tr>
 <tr>
-<td>フォア</td>
+<td> <b>Foreach</b> </td>
 <td>
-コレクションを反復処理し、各アイテムに対して手順を実行します。
+Iterate over a collection and perform steps for each item
 
 </td>
 
 <td>
 
-```yaml
-- foreach:
-    in: "data_list"
-    do:
-      - log: "Processing item {{_}}"
+```ヤム
+- 各:
+in: _.data_list # <-- コンテキスト変数にアクセスするための Python 式
+する：
+- ログ: "アイテム {{_.item}} を処理しています" # <-- コンテキスト変数にアクセスするための jinja テンプレート
 ```
 
 </td>
 </tr>
 <tr>
-<td>マップリデュース</td>
+<td> <b>Map-Reduce</b> </td>
 <td>
-コレクションをマップして結果を減らす
+Map over a collection and reduce the results
 
 </td>
 
 <td>
 
-```yaml
-- map_reduce:
-    over: "numbers"
-    map:
-      - evaluate:
-          squared: "_ ** 2"
-    reduce: "sum(results)"
+```ヤム
+- マップリデュース:
+over: _.numbers # <-- コンテキスト変数にアクセスするための Python 式
+地図：
+- 評価する：
+二乗: "_ ** 2"
+Reduce: 結果 + [_] # <-- (オプション) 結果を削減する Python 式。省略した場合、これがデフォルトになります。
+```
+
+```ヤム
+- マップリデュース:
+以上: _.topics
+地図：
+- プロンプト: {{_}} に関するエッセイを書く
+並列度: 10
 ```
 
 </td>
 </tr>
 <tr>
-<td>平行</td>
+<td> <b>Parallel</b> </td>
 <td>
-複数のステップを並行して実行する
+Run multiple steps in parallel
 
 </td>
 
 <td>
 
-```yaml
-- parallel:
-    - tool: web_search
-      arguments:
-        query: "AI news"
-    - tool: weather_check
-      arguments:
-        location: "New York"
+```ヤム
+- 平行：
+- ツール: web_search
+引数:
+クエリ: 「AI ニュース」
+- ツール: weather_check
+引数:
+場所: '"ニューヨーク"'
 ```
 
 </td>
 </tr>
 </table>
 
-#### 条件付きステップ
+#### Conditional Steps
 
 <table>
 <tr>
-<td>名前</td> <td>について</td><td>構文</td>
+<th> Name </th> <th> About </th><th>Syntax</th>
 </tr>
 <tr>
-<td>If-Else</td>
+<td> <b>If-Else</b> </td>
 <td>
-ステップの条件付き実行
+Conditional execution of steps
 
 </td>
 
 <td>
 
-```yaml
-- if: "score > 0.8"
-  then:
-    - log: "High score achieved"
-  else:
-    - log: "Score needs improvement"
+```ヤム
+- if: _.score > 0.8 # <-- Python 式
+それから：
+- ログ: 高得点を達成
+それ以外：
+- エラー: スコアの改善が必要です
 ```
 
 </td>
 </tr>
 <tr>
-<td>スイッチ</td>
+<td> <b>Switch</b> </td>
 <td>
-複数の条件に基づいてステップを実行する
+Execute steps based on multiple conditions
 
 </td>
 
 <td>
 
-```yaml
-- switch:
-    - case: "category == 'A'"
-      then:
-        - log: "Category A processing"
-    - case: "category == 'B'"
-      then:
-        - log: "Category B processing"
-    - case: "_" # Default case
-      then:
-        - log: "Unknown category"
+```ヤム
+- スイッチ:
+- ケース: _.category == 'A'
+それから：
+- ログ: 「カテゴリー A 処理」
+- ケース: _.category == 'B'
+それから：
+- ログ: 「カテゴリー B 処理」
+- case: _ # デフォルトのケース
+それから：
+- エラー: 不明なカテゴリ
 ```
 
 </td>
 </tr>
 </table>
 
-#### その他の制御フロー
+#### Other Control Flow
 
 <table>
 <tr>
-<td>名前</td> <td>について</td><td>構文</td>
+<th> Name </th> <th> About </th><th>Syntax</th>
 </tr>
 <tr>
-<td>寝る</td>
+<td> <b>Sleep</b> </td>
 <td>
-指定した期間ワークフローを一時停止する
+Pause the workflow for a specified duration
 
 </td>
 
 <td>
 
-```yaml
-- sleep:
-    seconds: 30
+```ヤム
+- 寝る：
+秒: 30
+分数: 1
+時間数: 1
+日数: 1
 ```
 
 </td>
 </tr>
 <tr>
-<td>戻る</td>
+<td> <b>Return</b> </td>
 <td>
-ワークフローから値を返す
+Return a value from the workflow
+
+<br><br><b>Note:</b> The return step uses Python expressions.
 
 </td>
 
 <td>
 
-```yaml
-- return:
-    result: "Task completed successfully"
+```ヤム
+- 戻る：
+結果: '"タスクは正常に完了しました"' # <-- Python 式
+time: datetime.now().isoformat() # <-- python 式
 ```
 
 </td>
 </tr>
 <tr>
-<td>収率</td>
+<td> <b>Yield</b> </td>
 <td>
-サブワークフローを実行し、完了を待ちます
+Run a subworkflow and await its completion
 
 </td>
 
 <td>
 
-```yaml
-- yield:
-    workflow: "data_processing_subflow"
-    arguments:
-      input_data: "{{raw_data}}"
+```ヤム
+- 収率：
+ワークフロー: process_data
+引数:
+input_data: _.raw_data # <-- Python式
 ```
 
 </td>
 </tr>
 </tr>
 <tr>
-<td>エラー</td>
+<td> <b>Error</b> </td>
 <td>
-エラーメッセージを指定してエラーを処理する
+Handle errors by specifying an error message
 
 </td>
 
 <td>
 
-```yaml
-- error: "Invalid input provided"
+```ヤム
+- エラー:「無効な入力が提供されています」# <-- 文字列のみ
 ```
 
 </td>
 </tr>
 </table>
 
-各ステップ タイプは、高度な AI ワークフローを構築する上で特定の目的を果たします。この分類は、Julep タスクで使用できるさまざまな制御フローと操作を理解するのに役立ちます。
+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.
 
-## ツールの種類
-
-エージェントには、さまざまな「ツール」へのアクセスを許可できます。これは、基盤モデルが一連の入力を使用して「呼び出す」ことができるプログラム インターフェイスです。たとえば、インターネットで何らかの情報を検索するには、`web_search(query)` ツールを使用します。
-
-エージェント フレームワークとは異なり、julep はエージェントの実行を管理する _バックエンド_ です。クライアントは SDK を使用してエージェントと対話できます。julep はタスクの実行と統合の実行を担当します。
-
-julep のツールは次のいずれかになります。
-
-### ユーザー定義の `functions`
-
-これらは、[openai] の関数呼び出しの仕組みと同様に、モデルに選択させることができる関数シグネチャです。例:
-
-```yaml
-name: Example system tool task
-description: List agents using system call
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-tools:
-  - name: send_notification
-    description: Send a notification to the user
-    type: function
-    function:
-      parameters:
-        type: object
-        properties:
-          text:
-            type: string
-            description: Content of the notification
+## Tool Types
 
-main:
-  - tool: send_notification
-    arguments:
-      content: hi
-```
+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.
 
-julep は、_ユーザー定義関数_ に遭遇するたびに一時停止し、クライアントに制御を戻し、クライアントが関数呼び出しを実行して結果を julep に返すのを待ちます。
+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.
 
-> [!ヒント]
-> **サンプルクックブック**: [cookbooks/13-Error_Handling_and_Recovery.py](https://github.com/julep-ai/julep/blob/dev/cookbooks/13-Error_Handling_and_Recovery.py)
+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.
 
-### `システム` ツール
+### User-defined `functions`
 
-タスク実行のトリガー、メタデータ フィールドへの追加など、julep API 自体を呼び出すために使用できる組み込みツール。
-`system` ツールはバックエンドに組み込まれています。必要に応じて自動的に実行されます。クライアント側からのアクションは必要ありません。
+These are function signatures that you can give the model to choose from, similar to how [openai]'s function-calling works. An example:
 
-例えば、
+```ヤム
+名前: システムツールタスクの例
+説明: システムコールを使用してエージェントを一覧表示する
 
-```yaml
-name: Example system tool task
-description: List agents using system call
+ツール:
+- 名前: send_notification
+説明: ユーザーに通知を送信する
+タイプ: 関数
+関数：
+パラメータ:
+タイプ: オブジェクト
+プロパティ:
+文章：
+タイプ: 文字列
+説明: 通知の内容
 
-tools:
-  - name: list_agents
-    description: List all agents
-    type: system
-    system:
-      resource: agent
-      operation: list
-main:
-  - tool: list_agents
-    arguments:
-      limit: 10
+主要：
+- ツール: send_notification
+引数:
+内容: '"hi"' # <-- Python 式
 ```
 
-> [!ヒント]
-> **サンプルクックブック**: [cookbooks/10-Document_Management_and_Search.py​​](https://github.com/julep-ai/julep/blob/dev/cookbooks/10-Document_Management_and_Search.py​​)
-
-### 組み込みの `integrations`
+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.
 
-Julep には、いくつかの組み込み統合が付属しています (以下のセクションで説明)。`integration` ツールは、julep バックエンドで直接実行されます。実行時に必要な追加パラメータは、エージェント/セッション/ユーザーの `metadata` フィールドで設定できます。
+> [!TIP]
+> **Example cookbook**: [cookbooks/13-Error_Handling_and_Recovery.py](https://github.com/julep-ai/julep/blob/dev/cookbooks/13-Error_Handling_and_Recovery.py)
 
-> [!ヒント]
-> **サンプルクックブック**: [cookbooks/01-Website_Crawler_using_Spider.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/01-Website_Crawler_using_Spider.ipynb)
-
-julep バックエンドには、次のプロバイダーからの統合サードパーティ ツールが付属しています。
+### `system` tools
 
-- [composio](https://composio.dev)
-- [匿名](https://anon.com)
-- [langchain ツールキット](https://python.langchain.com/v0.2/docs/integrations/toolkits/)
+Built-in tools that can be used to call the julep APIs themselves, like triggering a task execution, appending to a metadata field, etc.  
 
-_Github、Gitlab、Gmail、Jira、MultiOn、Slack_ ツールキットのサポートが計画されています。
+`system` tools are built into the backend. They get executed automatically when needed. They do _not_ require any action from the client-side.
 
-_composio_ と _anon_ はサードパーティプロバイダーであるため、それらのツールではアカウントリンクを設定する必要があります。
+For example,
 
-### 直接の `api_calls`
+```ヤム
+名前: システムツールタスクの例
+説明: システムコールを使用してエージェントを一覧表示する
 
-julep は、ワークフロー実行中にツール呼び出しとして直接 API 呼び出しを行うこともできます。`integration` と同様に、追加のランタイム パラメータは `metadata` フィールドから読み込まれます。
+ツール:
+- 名前: list_agent_docs
+説明: 指定されたエージェントのすべてのドキュメントを一覧表示します
+タイプ: システム
+システム：
+リソース: エージェント
+サブリソース: doc
+操作: リスト
 
-例えば、
+主要：
+- ツール: list_agents
+引数:
+制限: 10 # <-- Python式
+```
 
-```yaml
-name: Example api_call task
-tools:
-  - type: api_call
-    name: hello
-    api_call:
-      method: GET
-      url: https://httpbin.org/get
-main:
-  - tool: hello
-    arguments:
-      params:
-        test: _.input
+#### 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](https://github.com/julep-ai/julep/blob/dev/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](#integrations) for details on the available integrations.
+
+> [!TIP]
+> **Example cookbook**: [cookbooks/01-Website_Crawler_using_Spider.ipynb](https://github.com/julep-ai/julep/blob/dev/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 `integration`s, additional runtime parameters are loaded from `metadata` fields.
+
+For example,
+
+```ヤム
+名前: api_callタスクの例
+ツール:
+- タイプ: api_call
+名前: こんにちは
+API呼び出し:
+メソッド: GET
+URL: https://httpbin.org/get
+
+主要：
+- ツール: こんにちは
+引数:
+書式:
+test: _.input # <-- Python式
 ```
 
-## 統合
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-Julep は、AI エージェントの機能を拡張するさまざまな統合をサポートしています。利用可能な統合とサポートされている引数のリストは次のとおりです。
+## Integrations
+
+Julep supports various integrations that extend the capabilities of your AI agents. Here's a list of available integrations and their supported arguments:
 
 <table>
 
 <tr>
-<td>勇敢な検索</td>
+<td> <b>Brave Search</b> </td>
 <td>
 
-```yaml
-setup:
-  api_key: string # The API key for Brave Search
+```ヤム
+設定：
+api_key: 文字列 # Brave SearchのAPIキー
 
-arguments:
-  query: string # The search query for searching with Brave
+引数:
+query: 文字列 # Braveで検索するための検索クエリ
 
-output:
-  result: string # The result of the Brave Search
+出力：
+result: 文字列 # Brave Searchの結果
 ```
 
 </td>
 
 <td>
 
-**サンプルクックブック**: [cookbooks/03-SmartResearcher_With_WebSearch.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/03-SmartResearcher_With_WebSearch.ipynb)
+**Example cookbook**: [cookbooks/03-SmartResearcher_With_WebSearch.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/03-SmartResearcher_With_WebSearch.ipynb)
 
 </td>
 </tr>
 <tr>
-<td>ブラウザベース</td>
+<td> <b>BrowserBase</b> </td>
 <td>
 
-```yaml
-setup:
-  api_key: string # The API key for BrowserBase
-  project_id: string # The project ID for BrowserBase
-  session_id: string # (Optional) The session ID for BrowserBase
+```ヤム
+設定：
+api_key: 文字列 # BrowserBaseのAPIキー
+project_id: 文字列 # BrowserBase のプロジェクト ID
+session_id: 文字列 # (オプション) BrowserBaseのセッションID
 
-arguments:
-  urls: list[string] # The URLs for loading with BrowserBase
+引数:
+urls: list[string] # BrowserBaseで読み込むURL
 
-output:
-  documents: list # The documents loaded from the URLs
+出力：
+documents: list # URLから読み込まれたドキュメント
 ```
 
 </td>
 
 </tr>
 <tr>
-<td>メール</td>
+<td> <b>Email</b> </td>
 <td>
 
-```yaml
-setup:
-  host: string # The host of the email server
-  port: integer # The port of the email server
-  user: string # The username of the email server
-  password: string # The password of the email server
-
-arguments:
-  to: string # The email address to send the email to
-  from: string # The email address to send the email from
-  subject: string # The subject of the email
-  body: string # The body of the email
-
-output:
-  success: boolean # Whether the email was sent successfully
+```ヤム
+設定：
+ホスト: 文字列 # メールサーバーのホスト
+port: 整数 # メールサーバーのポート
+user: 文字列 # メールサーバーのユーザー名
+パスワード: 文字列 # メールサーバーのパスワード
+
+引数:
+to: 文字列 # メールを送信するメールアドレス
+from: 文字列 # メールを送信するメールアドレス
+subject: 文字列 # メールの件名
+body: 文字列 # メールの本文
+
+出力：
+success: boolean # メールが正常に送信されたかどうか
 ```
 
 </td>
 
 <td>
 
-**サンプルクックブック**: [cookbooks/00-Devfest-Email-Assistant.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/00-Devfest-Email-Assistant.ipynb)
+**Example cookbook**: [cookbooks/00-Devfest-Email-Assistant.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/00-Devfest-Email-Assistant.ipynb)
 
 </td>
 </tr>
 <tr>
-<td>スパイダー</td>
+<td> <b>Spider</b> </td>
 <td>
 
-```yaml
-setup:
-  spider_api_key: string # The API key for Spider
+```ヤム
+設定：
+spider_api_key: 文字列 # SpiderのAPIキー
 
-arguments:
-  url: string # The URL for which to fetch data
-  mode: string # The type of crawlers (default: "scrape")
-  params: dict # (Optional) The parameters for the Spider API
+引数:
+url: 文字列 # データを取得するURL
+mode: 文字列 # クローラーのタイプ (デフォルト: "scrape")
+params: dict # (オプション) Spider APIのパラメータ
 
-output:
-  documents: list # The documents returned from the spider
+出力：
+ドキュメント: リスト # スパイダーから返されたドキュメント
 ```
 
 </td>
 
 <td>
 
-**サンプルクックブック**: [cookbooks/01-Website_Crawler_using_Spider.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/01-Website_Crawler_using_Spider.ipynb)
+**Example cookbook**: [cookbooks/01-Website_Crawler_using_Spider.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/01-Website_Crawler_using_Spider.ipynb)
 
 </td>
 </tr>
 <tr>
-<td>天気</td>
+<td> <b>Weather</b> </td>
 <td>
 
-```yaml
-setup:
-  openweathermap_api_key: string # The API key for OpenWeatherMap
+```ヤム
+設定：
+openweathermap_api_key: 文字列 # OpenWeatherMapのAPIキー
 
-arguments:
-  location: string # The location for which to fetch weather data
+引数:
+location: 文字列 # 気象データを取得する場所
 
-output:
-  result: string # The weather data for the specified location
+出力：
+結果: 文字列 # 指定された場所の天気データ
 ```
 
 </td>
 
 <td>
 
-**サンプルクックブック**: [cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb)
+**Example cookbook**: [cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb)
 
 </td>
 </tr>
 </tr>
 <tr>
-<td>ウィキペディア</td>
+<td> <b>Wikipedia</b> </td>
 <td>
 
-```yaml
-arguments:
-  query: string # The search query string
-  load_max_docs: integer # Maximum number of documents to load (default: 2)
+```ヤム
+引数:
+query: 文字列 # 検索クエリ文字列
+load_max_docs: 整数 # 読み込むドキュメントの最大数 (デフォルト: 2)
 
-output:
-  documents: list # The documents returned from the Wikipedia search
+出力：
+ドキュメント: リスト # Wikipedia 検索から返されたドキュメント
 ```
 
 </td>
 
 <td>
 
-**サンプルクックブック**: [cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb)
+**Example cookbook**: [cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb](https://github.com/julep-ai/julep/blob/dev/cookbooks/04-TripPlanner_With_Weather_And_WikiInfo.ipynb)
 
 </td>
 </tr>
 </table>
 
-詳細については、[統合ドキュメント](https://docs.julep.ai/integrations)を参照してください。
+For more details, refer to our [Integrations Documentation](#integrations).
 
-## その他の機能
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-Julep は、AI ワークフローを強化するためのさまざまな高度な機能を提供します。
+## Other Features
 
-### エージェントへのツールの追加
+Julep offers a range of advanced features to enhance your AI workflows:
 
-外部ツールと API を統合してエージェントの機能を拡張します。
+### Adding Tools to Agents
 
-```python
-client.agents.tools.create(
-    agent_id=agent.id,
-    name="web_search",
-    description="Search the web for information.",
-    integration={
-        "provider": "brave",
-        "method": "search",
-        "setup": {"api_key": "your_brave_api_key"},
+Extend your agent's capabilities by integrating external tools and APIs:
+
+```パイソン
+クライアント.エージェント.ツール.作成(
+エージェントID=エージェントID、
+名前="ウェブ検索",
+description="Web で情報を検索します。",
+統合={
+「プロバイダー」：「勇敢な」、
+"メソッド": "検索",
+"セットアップ": {"api_key": "your_brave_api_key"},
     },
 )
 ```
 
-### セッションとユーザーの管理
+### Managing Sessions and Users
 
-Julep は、永続的なインタラクションのための堅牢なセッション管理を提供します。
+Julep provides robust session management for persistent interactions:
 
-```python
-session = client.sessions.create(
-    agent_id=agent.id,
-    user_id=user.id,
-    context_overflow="adaptive"
+```パイソン
+セッション = client.sessions.create(
+エージェントID=エージェントID、
+user_id=ユーザーID、
+context_overflow="適応型"
 )
 
-# Continue conversation in the same session
-response = client.sessions.chat(
-    session_id=session.id,
-    messages=[
+# 同じセッションで会話を続ける
+レスポンス = client.sessions.chat(
+session_id=セッションID、
+メッセージ=[
       {
-        "role": "user",
-        "content": "Follow up on the previous conversation."
+「役割」: 「ユーザー」、
+"content": "前回の会話をフォローアップします。"
       }
     ]
 )
 ```
 
-### ドキュメントの統合と検索
+### Document Integration and Search
 
-エージェントのドキュメントを簡単に管理および検索できます。
+Easily manage and search through documents for your agents:
 
-```python
-# Upload a document
-document = client.agents.docs.create(
-    title="AI advancements",
-    content="AI is changing the world...",
-    metadata={"category": "research_paper"}
+```パイソン
+# ドキュメントをアップロードする
+ドキュメント = client.agents.docs.create(
+title="AIの進歩",
+content="AI は世界を変えています...",
+メタデータ = {"カテゴリ": "研究論文"}
 )
 
-# Search documents
-results = client.agents.docs.search(
-    text="AI advancements",
-    metadata_filter={"category": "research_paper"}
+# ドキュメントを検索
+結果 = client.agents.docs.search(
+text="AIの進歩",
+metadata_filter={"category": "研究論文"}
 )
 ```
 
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
+＃＃ 参照
+
+### SDK リファレンス
+
+- **Node.js** [SDK リファレンス](https://github.com/julep-ai/node-sdk/blob/main/api.md) | [NPM パッケージ](https://www.npmjs.com/package/@julep/sdk)
+- **Python** [SDK リファレンス](https://github.com/julep-ai/python-sdk/blob/main/api.md) | [PyPI パッケージ](https://pypi.org/project/julep/)
+
+### API リファレンス
+
+エージェント、タスク、実行の詳細については、API ドキュメントをご覧ください。
+
+- [エージェント API](https://dev.julep.ai/api/docs#tag/agents)
+- [タスク API](https://dev.julep.ai/api/docs#tag/tasks)
+- [実行API](https://dev.julep.ai/api/docs#tag/executions)
+
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
+
 ## ローカルクイックスタート
 
 **要件**：
@@ -1251,26 +1522,23 @@ results = client.agents.docs.search(
 1. `git clone https://github.com/julep-ai/julep.git`
 2. `cd ジュレップ`
 3. `docker volume create cozo_backup`
-4. `docker volume create cozo_data`
+4. docker ボリュームを作成します cozo_data
 5. `cp .env.example .env # <-- このファイルを編集します`
 6. `docker compose --env-file .env --profile temporal-ui --profile single-tenant --profile self-hosted-db up --build`
 
-## SDK リファレンス
-
-- [Node.js SDK](https://github.com/julep-ai/node-sdk/blob/main/api.md)
-- [Python SDK](https://github.com/julep-ai/python-sdk/blob/main/api.md)
-
-## APIリファレンス
-
-エージェント、タスク、実行の詳細については、包括的な API ドキュメントをご覧ください。
+<div align="center">
+    <a href="#top">
+        <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
+    </a>
+</div>
 
-- [エージェント API](https://api.julep.ai/api/docs#tag/agents)
-- [タスク API](https://api.julep.ai/api/docs#tag/tasks)
-- [実行API](https://api.julep.ai/api/docs#tag/executions)
 
 *****
 
-## Julep と LangChain を比較する理由
+## Julep と LangChain などの違いは何ですか?
 
 ### さまざまなユースケース
 
@@ -1308,5 +1576,8 @@ LangChain は、プロンプトと API 呼び出しの線形チェーンを含
 <div align="center">
     <a href="#top">
         <img src="https://img.shields.io/badge/Back%20to%20Top-000000?style=for-the-badge&logo=github&logoColor=white" alt="Back to Top">
+    </a>&nbsp;|&nbsp;
+    <a href="#-table-of-contents">
+        <img src="https://img.shields.io/badge/Table%20of%20Contents-000000?style=for-the-badge&logo=github&logoColor=white" alt="Table of Contents">
     </a>
 </div>