English | 中文翻译 | 日本語翻訳 | French
ドキュメントを探索 (wip)
·
不和
·
𝕏
·
リンクトイン
[!注意] API キーを こちら から取得します。
貢献🌟（クリックして拡大）
Julep プロジェクトに新しい貢献者を迎えられることを嬉しく思います。プロジェクトを始めるのに役立つ「最初の良い問題」をいくつか作成しました。貢献する方法は次のとおりです。
- 貢献方法に関するガイドラインについては、CONTRIBUTING.md ファイルをご覧ください。
- good first issues を参照して、興味のあるタスクを見つけます。
- ご質問やご不明な点がございましたら、Discord チャンネルまでお気軽にお問い合わせください。
あなたの貢献は、大小を問わず私たちにとって貴重です。一緒に素晴らしいものを作りましょう！🚀
- 貢献者募集🌟
- はじめに
- 主な特徴
- 簡単な例
- インストール
- Python クイックスタート 🐍
- Node.js クイック スタート 🟩
- コンポーネント
- メンタルモデル
- コンセプト
- タスクの理解
- タスクのライフサイクル
- ワークフロー ステップの種類
- 共通手順
- キーと値のステップ
- 反復ステップ
- 条件付きステップ
- その他の制御フロー
- ツールの種類
- ユーザー定義の
functions システムツール- 利用可能な
systemリソースと操作 - 組み込みの
integrations - 直接の
api_calls - 統合
- その他の機能
- エージェントへのツールの追加
- セッションとユーザーの管理
- ドキュメントの統合と検索
- 参考
- SDKリファレンス
- APIリファレンス
- ローカルクイックスタート
- Julep と LangChain などの違いは何ですか?
- さまざまなユースケース
- 異なるフォームファクター
- 要約
＃＃ 導入
Julep は、過去のやり取りを記憶し、複雑なタスクを実行できる AI エージェントを作成するためのプラットフォームです。長期記憶を提供し、複数ステップのプロセスを管理します。
Julep を使用すると、意思決定、ループ、並列処理、多数の外部ツールや API との統合を組み込んだ複数ステップのタスクを作成できます。
多くの AI アプリケーションは、最小限の分岐によるプロンプトと API 呼び出しの単純な線形チェーンに制限されていますが、Julep は次のようなより複雑なシナリオを処理できるように構築されています。
- 複数のステップがある、
- モデルの出力に基づいて意思決定を行う
- 平行枝を生成し、
- たくさんのツールを使い、
- 長時間走る。
[!ヒント] 単純な質問に答えるだけでなく、複雑なタスクを処理し、過去のやり取りを記憶し、場合によっては他のツールや API も使用できる AI エージェントを構築したいとします。そこで Julep の出番です。詳細については、タスクの理解 をお読みください。
- 🧠 永続的な AI エージェント: 長期にわたるやり取りを通じてコンテキストと情報を記憶します。
- 💾 ステートフル セッション: 過去のやり取りを追跡して、パーソナライズされた応答を提供します。
- 🔄 複数ステップのタスク: ループと意思決定を含む複雑な複数ステップのプロセスを構築します。
- ⏳ タスク管理: 無期限に実行される可能性のある長時間実行タスクを処理します。
- 🛠️ 組み込みツール: タスクで組み込みツールと外部 API を使用します。
- 🔧 自己修復: Julep は失敗したステップを自動的に再試行し、メッセージを再送信し、一般的にタスクがスムーズに実行されるようにします。
- 📚 RAG: Julep のドキュメント ストアを使用して、独自のデータを取得して使用するためのシステムを構築します。
[!ヒント] Julep は、単純なプロンプト応答モデルを超えた AI ユースケースを必要とするアプリケーションに最適です。
次のことができる研究 AI エージェントを想像してください。
- トピックを選ぶ、
- そのトピックについて30個の検索クエリを考え出す
- ウェブ検索を並行して実行する
- 結果を要約します。
- 要約を Discord に送信します。
[!注意] Julepでは、これは単一のタスクになります80行のコードそして走る完全に管理されたすべて自動的に行われます。すべての手順は Julep の独自のサーバー上で実行されるため、何もする必要はありません。
実際の例を次に示します。
name: Research Agent
# Optional: Define the input schema for the task
input_schema:
type: object
properties:
topic:
type: string
description: The main topic to research
num_questions:
type: integer
description: The number of search queries to generate
# Define the tools that the agent can use
tools:
- name: web_search
type: integration
integration:
provider: brave
setup:
api_key: <your-brave-api-key>
- name: discord_webhook
type: api_call
api_call:
url: https://discord.com/api/webhooks/<your-webhook-id>/<your-webhook-token>
method: POST
headers:
Content-Type: application/json
# Special variables:
# - inputs: for accessing the input to the task
# - outputs: for accessing the output of previous steps
# - _: for accessing the output of the previous step
# Define the main workflow
main:
- prompt:
- role: system
content: >-
You are a research assistant.
Generate {{inputs[0].num_questions|default(30, true)}} diverse search queries related to the topic:
{{inputs[0].topic}}
Write one query per line.
unwrap: true
# Evaluate the search queries using a simple python expression
- evaluate:
search_queries: "_.split(NEWLINE)"
# Run the web search in parallel for each query
- over: "_.search_queries"
map:
tool: web_search
arguments:
query: "_"
parallelism: 5
# Collect the results from the web search
- evaluate:
search_results: _
# Summarize the results
- prompt:
- role: system
content: >
You are a research summarizer. Create a comprehensive summary of the following research results on the topic {{inputs[0].topic}}.
The summary should be well-structured, informative, and highlight key findings and insights. Keep the summary concise and to the point.
The length of the summary should be less than 150 words.
Here are the search results:
{{_.search_results}}
unwrap: true
settings:
model: gpt-4o-mini
- evaluate:
discord_message: |-
f'''
**Research Summary for {inputs[0].topic}**
{_}
'''
# Send the summary to Discord
- tool: discord_webhook
arguments:
json_:
content: _.discord_message[:2000] # Discord has a 2000 character limitこの例では、Julep は並列実行を自動的に管理し、失敗したステップを再試行し、API リクエストを再送信し、タスクが完了するまで確実に実行し続けます。
これは 30 秒以内に実行され、次の出力を返します。
AIに関する研究概要 （クリックして拡大）
AIに関する研究概要
人工知能 (AI) の分野は近年、機械が環境を認識し、データから学習し、意思決定を行える方法とテクノロジーの開発により、大きな進歩を遂げています。この概要では、AI に関連するさまざまな研究結果から得られた洞察に主に焦点を当てています。
- AIの定義と範囲:
- AI は、学習、推論、問題解決など、人間のような知能を必要とするタスクを実行できるシステムの作成に重点を置いたコンピューター サイエンスの分野として定義されています (Wikipedia)。
- 機械学習、自然言語処理、ロボット工学、コンピュータービジョンなど、さまざまなサブフィールドを網羅しています。
- 影響と応用:
- AI テクノロジーはさまざまな分野に統合され、効率性と生産性を向上させています。その応用範囲は、自律走行車やヘルスケア診断から顧客サービスの自動化や財務予測まで多岐にわたります (OpenAI)。
- AI をすべての人にとって有益なものにするという Google の取り組みは、さまざまなプラットフォームでユーザー エクスペリエンスを強化することで日常生活を大幅に改善する可能性を強調しています (Google AI)。
- 倫理的配慮:
- プライバシー、偏見、意思決定プロセスの説明責任に関する懸念など、AI の倫理的影響に関する議論が続いています。AI 技術の安全で責任ある使用を保証するフレームワークの必要性が強調されています (OpenAI)。
- 学習メカニズム:
- AI システムは、教師あり学習、教師なし学習、強化学習などのさまざまな学習メカニズムを活用します。これらの方法により、AI は過去の経験やデータから学習することで、時間の経過とともにパフォーマンスを向上させることができます (Wikipedia)。
- 教師あり学習と教師なし学習の区別は重要です。教師あり学習はラベル付きデータに依存しますが、教師なし学習は事前定義されたラベルなしでパターンを識別します (教師なし)。
- 今後の方向性:
- 今後の AI 開発では、AI システムの解釈可能性と透明性を高め、正当な判断と行動を提供できるようにすることに重点が置かれると予想されます (OpenAI)。
- AI システムをよりアクセスしやすく、ユーザーフレンドリーなものにし、さまざまな人口統計や業界での幅広い導入を促進する動きもあります (Google AI)。
AI は複数の領域に変革をもたらす力を持ち、産業の再構築や生活の質の向上が期待されています。しかし、AI の機能が拡大するにつれて、倫理的および社会的影響に対処することが極めて重要になります。AI の将来像を見据えるには、技術者、倫理学者、政策立案者による継続的な研究と協力が不可欠です。
Julep を使い始めるには、npm または pip を使用してインストールします。
Node.js:
npm install @julep/sdk
# or
bun add @julep/sdkPython:
pip install julep[!注意] API キーを こちら から取得します。
ベータ版では、Discord に連絡して、API キーのレート制限を解除することもできます。
[!ヒント] 💻 あなたは「コードを見せてください!™」タイプの人ですか? 始めるにあたって役立つクックブックを多数作成しました。クックブック をチェックして、例を参照してください。
💡 Julep をベースに構築できるアイデアもたくさんあります。アイデアのリスト をチェックして、インスピレーションを得てください。
### Step 0: Setup
import time
import yaml
from julep import Julep # or AsyncJulep
client = Julep(api_key="your_julep_api_key")
### Step 1: Create an Agent
agent = client.agents.create(
name="Storytelling Agent",
model="claude-3.5-sonnet",
about="You are a creative storyteller that crafts engaging stories on a myriad of topics.",
)
### Step 2: Create a Task that generates a story and comic strip
task_yaml = """
name: Storyteller
description: Create a story based on an idea.
tools:
- name: research_wikipedia
type: integration
integration:
provider: wikipedia
method: search
main:
# Step 1: Generate plot idea
- prompt:
- role: system
content: You are {{agent.name}}. {{agent.about}}
- role: user
content: >
Based on the idea '{{_.idea}}', generate a list of 5 plot ideas. Go crazy and be as creative as possible. Return your output as a list of long strings inside ```応答の最後に 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
- evaluate:
research_queries: load_yaml(_.split('```yaml')[1].split('```')[0].strip())
# Step 3: Research each plot idea
- foreach:
in: _.research_queries
do:
tool: research_wikipedia
arguments:
query: _
- evaluate:
wikipedia_results: 'NEWLINE.join([f"- {doc.metadata.title}: {doc.metadata.summary}" for item in _ for doc in item.documents])'
# Step 4: Think and deliberate
- prompt:
- role: system
content: You are {{agent.name}}. {{agent.about}}
- role: user
content: |-
Before we write the story, let's think and deliberate. Here are some plot ideas:
{% for idea in outputs[1].plot_ideas %}
- {{idea}}
{% endfor %}
Here are the results from researching the plot ideas on Wikipedia:
{{_.wikipedia_results}}
Think about the plot ideas critically. Combine the plot ideas with the results from Wikipedia to create a detailed plot for a story.
Write down all your notes and thoughts.
Then finally write the plot as a yaml object inside ```応答の最後に 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())"
"""
タスク = client.tasks.create(
エージェントID=エージェントID、
**yaml.safe_load(タスクyaml)
)
### ステップ3: タスクを実行する
実行 = client.executions.create(
タスクID=タスクID、
input={"idea": "飛ぶことを学ぶ猫"}
)
# 🎉 ストーリーと漫画パネルが生成される様子をご覧ください
while (result := client.executions.get(execution.id)).status が ['succeeded', 'failed'] の範囲外です:
print(結果.ステータス、結果.出力)
時間.睡眠(1)
# 📦 実行が完了したら、結果を取得します
result.status == "成功"の場合:
print(結果.出力)
それ以外：
例外(結果.エラー)を発生させるYou can find the full python example here.
|
// ステップ 0: セットアップ
dotenv は、次のコードで定義されます。
Julep の SDK を実装するには、次の手順に従ってください。
yaml を require します。
config() を呼び出します。
constクライアント = 新しいジュレップ({
APIキー: process.env.JULEP_API_KEY、
環境: process.env.JULEP_ENVIRONMENT || "production",
});
/* ステップ 1: エージェントを作成する */
非同期関数createAgent() {
const エージェント = クライアント.エージェント.作成を待機します({
名前: 「ストーリーテリングエージェント」
モデル: "claude-3.5-sonnet",
について：
「あなたは、さまざまなトピックについて魅力的なストーリーを作り上げることができる創造的なストーリーテラーです。」
});
返品エージェント;
}
/* ステップ 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())"
`;
非同期関数createTask(agentId) {
const タスク = client.tasks.create(agentId, yaml.parse(taskYaml)) を待機します。
タスクを返す。
}
/* ステップ 3: タスクを実行する */
非同期関数executeTask(taskId) {
const 実行 = クライアント.実行.作成(taskId, {
入力: { アイデア: 「飛ぶことを学ぶ猫」 },
});
// 🎉 ストーリーと漫画パネルが生成される様子をご覧ください
（真）の間{
const 結果 = client.executions.get(execution.id); を待機します。
console.log(結果のステータス、結果の出力);
if (result.status === "成功" || result.status === "失敗") {
// 📦 実行が終了したら、結果を取得します
if (result.status === "成功") {
console.log(結果の出力);
} それ以外 {
新しいエラーをスローします(result.error);
}
壊す;
}
新しい Promise((resolve) => setTimeout(resolve, 1000)) を待機します。
}
}
// 例を実行するためのメイン関数
非同期関数main() {
試す {
const エージェント = createAgent() を待機します。
const タスク = createTask(agent.id);
タスクの実行を待機します(task.id);
} キャッチ（エラー）{
console.error("エラーが発生しました:", error);
}
}
主要（）
.then(() => console.log("完了"))
.catch(コンソール.エラー);
You can find the full Node.js example here.
|
Julep is made up of the following components:
- Julep Platform: The Julep platform is a cloud service that runs your workflows. It includes a language for describing workflows, a server for running those workflows, and an SDK for interacting with the platform.
- Julep SDKs: Julep SDKs are a set of libraries for building workflows. There are SDKs for Python and JavaScript, with more on the way.
- Julep API: The Julep API is a RESTful API that you can use to interact with the Julep platform.
Think of Julep as a platform that combines both client-side and server-side components to help you build advanced AI agents. Here's how to visualize it:
-
Your Application Code:
- You can use the Julep SDK in your application to define agents, tasks, and workflows.
- The SDK provides functions and classes that make it easy to set up and manage these components.
-
Julep Backend Service:
- The SDK communicates with the Julep backend over the network.
- The backend handles execution of tasks, maintains session state, stores documents, and orchestrates workflows.
-
Integration with Tools and APIs:
- Within your workflows, you can integrate external tools and services.
- The backend facilitates these integrations, so your agents can, for example, perform web searches, access databases, or call third-party APIs.
Julep is built on several key technical components that work together to create powerful AI workflows:
グラフTD
ユーザー[ユーザー] ==> セッション[セッション]
セッション --> エージェント[エージェント]
エージェント --> タスク[タスク]
エージェント --> LLM[大規模言語モデル]
タスク --> ツール[ツール]
エージェント --> ドキュメント[ドキュメント]
ドキュメント --> VectorDB[ベクターデータベース]
タスク --> 実行[実行]
classDef client fill:#9ff、stroke:#333、stroke-width:1px;
クラス User クライアント;
classDef core fill:#f9f、stroke:#333、stroke-width:2px;
クラス Agent、Tasks、Session コア;
- Agents: AI-powered entities backed by large language models (LLMs) that execute tasks and interact with users.
- Users: Entities that interact with agents through sessions.
- Sessions: Stateful interactions between agents and users, maintaining context across multiple exchanges.
- Tasks: Multi-step, programmatic workflows that agents can execute, including various types of steps like prompts, tool calls, and conditional logic.
- Tools: Integrations that extend an agent's capabilities, including user-defined functions, system tools, or third-party API integrations.
- Documents: Text or data objects associated with agents or users, vectorized and stored for semantic search and retrieval.
- Executions: Instances of tasks that have been initiated with specific inputs, with their own lifecycle and state machine.
|
Tasks are the core of Julep's workflow system. They allow you to define complex, multi-step AI workflows that your agents can execute. Here's a brief overview of task components:
- Name, Description and Input Schema: Each task has a unique name and description for easy identification. An input schema (optional) that is used to validate the input to the task.
- Main Steps: The core of a task, defining the sequence of actions to be performed. Each step can be a prompt, tool call, evaluate, wait_for_input, log, get, set, foreach, map_reduce, if-else, switch, sleep, or return. (See Types of Workflow Steps for more details)
- Tools: Optional integrations that extend the capabilities of your agent during task execution.
You create a task using the Julep SDK and specify the main steps that the agent will execute. When you execute a task, the following lifecycle happens:
シーケンス図
参加者Dをあなたのコードとして
参加者C（ジュレップクライアント）
参加者Sはジュレップサーバーとして
D->>C: タスクの作成
C->>S: 実行を送信
Sの上のメモ: タスクの実行
Sに関する注意: 状態の管理
S-->>C: 実行イベント
C-->>D: 進捗状況の更新
S->>C: 実行完了
C->>D: 最終結果
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:
| Name | About | Syntax |
|---|---|---|
| Prompt |
Send a message to the AI model and receive a response
Note: The prompt step uses Jinja templates and you can access context variables in them. |
|
| Tool Call |
Execute an integrated tool or API that you have previously declared in the task.
Note: The tool call step uses Python expressions inside the arguments. |
|
| Evaluate |
Perform calculations or manipulate data
Note: The evaluate step uses Python expressions. |
|
| Wait for Input |
Pause workflow until input is received. It accepts an `info` field that can be used by your application to collect input from the user.
|
|
| Log |
Log a specified value or message.
|
|
| Name | About | Syntax |
|---|---|---|
| Get | Retrieve a value from the execution's key-value store. |
|
| Set |
Assign a value to a key in the execution's key-value store.
|
|
| Name | About | Syntax |
|---|---|---|
| Foreach | Iterate over a collection and perform steps for each item |
|
| Map-Reduce | Map over a collection and reduce the results |
|
| Parallel | Run multiple steps in parallel |
|
| Name | About | Syntax |
|---|---|---|
| If-Else | Conditional execution of steps |
|
| Switch | Execute steps based on multiple conditions |
|
| Name | About | Syntax |
|---|---|---|
| Sleep | Pause the workflow for a specified duration |
|
| Return |
Return a value from the workflow
|
|
| Yield | Run a subworkflow and await its completion |
|
| Error | Handle errors by specifying an error message |
|
Each step type serves a specific purpose in building sophisticated AI workflows. This categorization helps in understanding the various control flows and operations available in Julep tasks.
|
Agents can be given access to a number of "tools" -- any programmatic interface that a foundation model can "call" with a set of inputs to achieve a goal. For example, it might use a web_search(query) tool to search the Internet for some information.
Unlike agent frameworks, julep is a backend that manages agent execution. Clients can interact with agents using our SDKs. julep takes care of executing tasks and running integrations.
Tools in julep can be one of:
- 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. systemtools: Built-in tools that can be used to call the julep APIs themselves, like triggering a task execution, appending to a metadata field, etc.integrations: Built-in third party tools that can be used to extend the capabilities of your agents.api_calls: Direct api calls during workflow executions as tool calls.
These are function signatures that you can give the model to choose from, similar to how [openai]'s function-calling works. An example:
名前: システムツールタスクの例
説明: システムコールを使用してエージェントを一覧表示する
ツール:
- 名前: send_notification
説明: ユーザーに通知を送信する
タイプ: 関数
関数：
パラメータ:
タイプ: オブジェクト
プロパティ:
文章：
タイプ: 文字列
説明: 通知の内容
主要：
- ツール: send_notification
引数:
内容: '"hi"' # <-- Python 式
Whenever julep encounters a user-defined function, it pauses, giving control back to the client and waits for the client to run the function call and give the results back to julep.
Built-in tools that can be used to call the julep APIs themselves, like triggering a task execution, appending to a metadata field, etc.
system tools are built into the backend. They get executed automatically when needed. They do not require any action from the client-side.
For example,
名前: システムツールタスクの例
説明: システムコールを使用してエージェントを一覧表示する
ツール:
- 名前: list_agent_docs
説明: 指定されたエージェントのすべてのドキュメントを一覧表示します
タイプ: システム
システム：
リソース: エージェント
サブリソース: doc
操作: リスト
主要：
- ツール: list_agents
引数:
制限: 10 # <-- Python式
-
agent:list: List all agents.get: Get a single agent by id.create: Create a new agent.update: Update an existing agent.delete: Delete an existing agent.
-
user:list: List all users.get: Get a single user by id.create: Create a new user.update: Update an existing user.delete: Delete an existing user.
-
session:list: List all sessions.get: Get a single session by id.create: Create a new session.update: Update an existing session.delete: Delete an existing session.chat: Chat with a session.history: Get the chat history with a session.
-
task:list: List all tasks.get: Get a single task by id.create: Create a new task.update: Update an existing task.delete: Delete an existing task.
-
doc(subresource foragentanduser):list: List all documents.create: Create a new document.delete: Delete an existing document.search: Search for documents.
Additional operations available for some resources:
embed: Embed a resource (specific resources not specified in the provided code).change_status: Change the status of a resource (specific resources not specified in the provided code).chat: Chat with a resource (specific resources not specified in the provided code).history: Get the chat history with a resource (specific resources not specified in the provided code).create_or_update: Create a new resource or update an existing one (specific resources not specified in the provided code).
Note: The availability of these operations may vary depending on the specific resource and implementation details.
[!TIP] > Example cookbook: cookbooks/06-browser-use.ipynb
Julep comes with a number of built-in integrations (as described in the section below). integration tools are directly executed on the julep backend. Any additional parameters needed by them at runtime can be set in the agent/session/user's metadata fields.
See Integrations for details on the available integrations.
[!TIP] > Example cookbook: cookbooks/01-website-crawler.ipynb
julep can also directly make api calls during workflow executions as tool calls. Same as integrations, additional runtime parameters are loaded from metadata fields.
For example,
名前: api_callタスクの例
ツール:
- タイプ: api_call
名前: こんにちは
API呼び出し:
メソッド: GET
URL: https://httpbin.org/get
主要：
- ツール: こんにちは
引数:
書式:
test: _.input # <-- Python式
Julep supports various integrations that extend the capabilities of your AI agents. Here's a list of available integrations and their supported arguments:
| Brave Search |
|
Example cookbook: cookbooks/02-sarcastic-news-headline-generator.ipynb |
| BrowserBase |
|
Example cookbook: cookbooks/06-browser-use.ipynb |
|
Example cookbook: cookbooks/00-Devfest-Email-Assistant.ipynb |
|
| Spider |
|
Example cookbook: cookbooks/01-website-crawler.ipynb |
| Weather |
|
Example cookbook: cookbooks/03-trip-planning-assistant.ipynb |
| Wikipedia |
|
Example cookbook: cookbooks/03-trip-planning-assistant.ipynb |
| FFmpeg |
|
|
| Llama Parse |
|
Example cookbook: cookbooks/07-personalized-research-assistant.ipynb |
| Cloudinary |
|
Example cookbook: cookbooks/05-video-processing-with-natural-language.ipynb |
| Arxiv |
|
Example cookbook: cookbooks/07-personalized-research-assistant.ipynb |
For more details, refer to our Integrations Documentation.
|
Julep offers a range of advanced features to enhance your AI workflows:
Extend your agent's capabilities by integrating external tools and APIs:
クライアント.エージェント.ツール.作成(
エージェントID=エージェントID、
名前="ウェブ検索",
description="Web で情報を検索します。",
統合={
「プロバイダー」：「勇敢な」、
"メソッド": "検索",
"セットアップ": {"api_key": "your_brave_api_key"},
},
)
Julep provides robust session management for persistent interactions:
セッション = client.sessions.create(
エージェントID=エージェントID、
user_id=ユーザーID、
context_overflow="適応型"
)
# 同じセッションで会話を続ける
レスポンス = client.sessions.chat(
session_id=セッションID、
メッセージ=[
{
「役割」: 「ユーザー」、
"content": "前回の会話をフォローアップします。"
}
]
)
Easily manage and search through documents for your agents:
# ドキュメントをアップロードする
ドキュメント = client.agents.docs.create(
title="AIの進歩",
content="AI は世界を変えています...",
メタデータ = {"カテゴリ": "研究論文"}
)
# ドキュメントを検索
結果 = client.agents.docs.search(
text="AIの進歩",
metadata_filter={"category": "研究論文"}
)
＃＃ 参照
- Node.js SDK リファレンス | NPM パッケージ
- Python SDK リファレンス | PyPI パッケージ
エージェント、タスク、実行の詳細については、API ドキュメントをご覧ください。
|
要件：
- 最新の docker compose がインストールされている
手順:
git clone https://github.com/julep-ai/julep.gitcd ジュレップdocker volume create cozo_backup- docker ボリュームを作成します cozo_data
cp .env.example .env # <-- このファイルを編集しますdocker compose --env-file .env --profile temporal-ui --profile single-tenant --profile self-hosted-db up --build
|
LangChain と Julep は、AI 開発スタック内で異なる重点を置いたツールと考えてください。
LangChain は、プロンプトのシーケンスを作成し、LLM とのやり取りを管理するのに最適です。多数の事前構築された統合を備えた大規模なエコシステムを備えているため、何かをすぐに起動して実行したい場合に便利です。LangChain は、プロンプトと API 呼び出しの線形チェーンを含む単純なユースケースに適しています。
一方、Julep は、長期的なインタラクションでコンテキストを維持できる永続的な AI エージェントの構築に重点を置いています。複数ステップのタスク、条件付きロジック、エージェントのプロセス内で直接さまざまなツールや API との統合を伴う複雑なワークフローが必要な場合に効果を発揮します。永続的なセッションと複雑なワークフローを管理するために、ゼロから設計されています。
以下のことが必要となる複雑な AI アシスタントの構築を考えている場合には、Julep を使用してください。
- 数日または数週間にわたってユーザーのインタラクションを追跡します。
- 毎日のサマリーの送信やデータ ソースの監視などのスケジュールされたタスクを実行します。
- 以前のやり取りや保存されたデータに基づいて決定を下します。
- ワークフローの一部として複数の外部サービスと対話します。
そして、Julep は、ゼロから構築する必要なく、これらすべてをサポートするインフラストラクチャを提供します。
Julep は、ワークフローを記述するための言語、それらのワークフローを実行するためのサーバー、およびプラットフォームと対話するための SDK を含む プラットフォーム です。Julep で何かを構築するには、ワークフローの説明を YAML で記述し、クラウドでワークフローを実行します。
Julep は、負荷の高い、複数のステップから成る、長時間実行されるワークフロー向けに構築されており、ワークフローの複雑さに制限はありません。
LangChain は、プロンプトとツールの線形チェーンを構築するためのいくつかのツールとフレームワークを含む ライブラリ です。LangChain を使用して何かを構築するには、通常、使用するモデル チェーンを設定して実行する Python コードを記述します。
LangChain は、プロンプトと API 呼び出しの線形チェーンを含む単純なユースケースでは十分であり、実装も迅速です。
＃＃＃ 要約すれば
ステートレスまたは短期的なコンテキストで LLM インタラクションとプロンプト シーケンスを管理する必要がある場合は、LangChain を使用します。
高度なワークフロー機能、永続的なセッション、複雑なタスク オーケストレーションを備えたステートフル エージェント用の堅牢なフレームワークが必要な場合は、Julep を選択してください。
|