Translation Not Available Yet

 

     

Discord · 𝕏 · LinkedIn

🎉 Ankündigung: Julep Open Responses API (Alpha)

Julep ist eine serverlose Plattform, die Data- und ML-Teams beim Aufbau anspruchsvoller AI-Workflows unterstützt. Sie bietet eine robuste Grundlage für die Orchestrierung komplexer AI-Operationen, die Verwaltung des Zustands über Interaktionen hinweg und die Integration mit Ihrer bestehenden Dateninfrastruktur und Tools.

Egal, ob Sie Datenpipelines erstellen oder AI-Workflows entwickeln – mit Julep lassen sich LLM-gestützte Workflows einfach zusammenstellen und skalieren, ohne dass Sie sich um die Infrastruktur kümmern müssen. Stellen Sie sich vor, Sie möchten einen AI-Agenten bauen, der mehr kann als nur einfache Fragen zu beantworten – er muss komplexe Aufgaben bewältigen, sich an vergangene Interaktionen erinnern und vielleicht sogar andere Tools oder APIs nutzen. Hier kommt Julep ins Spiel. Unsere Plattform übernimmt die schwere Arbeit, sodass Sie sich auf die Entwicklung intelligenter Lösungen für Ihr Unternehmen konzentrieren können.

💡 Um mehr über Julep zu erfahren, lesen Sie die Dokumentation.

📖 Inhaltsverzeichnis

• ✨ Hauptfunktionen
• 🧠 Mentales Modell
• 📦 Installation
  • 🛠️ Julep SDKs
  • 🛠️ Julep CLI
• 🚀 Schnellstart
  • Was kommt als Nächstes?
• 🔍 Referenz
  • 📚 SDK-Referenz
  • 🛠️ API-Referenz
• 💻 Lokales Setup
  • 1. Repository klonen
  • 2. Zum Stammverzeichnis navigieren
  • 3. Umgebungsvariablen einrichten
  • 4. Docker-Volume für Backups erstellen
  • 5. Projekt mit Docker Compose starten
  • 6. Interaktion
  • 7. Fehlerbehebung
• 👥 Mitwirkende
  • Werden Sie Teil unserer Community! 🌟
• 📄 Lizenz

✨ Hauptfunktionen

💡 Um mehr über Julep zu erfahren, lesen Sie die Dokumentation.

🧠 Mentales Modell

Julep besteht aus den folgenden Komponenten:

• Julep-Plattform: Die Julep-Plattform ist ein Cloud-Dienst, der Ihre Workflows ausführt. Sie umfasst eine Sprache zur Beschreibung von Workflows, einen Server zur Ausführung dieser Workflows und ein SDK zur Interaktion mit der Plattform.
• Julep SDKs: Die Julep SDKs sind eine Sammlung von Bibliotheken zum Erstellen von Workflows. Es gibt SDKs für Python und JavaScript, weitere sind in Arbeit.
• Julep CLI: Die Julep CLI ist ein Befehlszeilentool, das Ihnen die direkte Interaktion mit der Julep-Plattform von Ihrem Terminal aus ermöglicht.
• Julep API: Die Julep API ist eine RESTful-API, die Sie zur Interaktion mit der Julep-Plattform verwenden können.

Stellen Sie sich Julep als eine Plattform vor, die sowohl client- als auch serverseitige Komponenten kombiniert, um Ihnen beim Aufbau fortschrittlicher AI-Agenten zu helfen. So können Sie es visualisieren:

1. Ihr Anwendungscode:

   • Sie können das Julep SDK in Ihrer Anwendung verwenden, um Agenten, Aufgaben und Workflows zu definieren.
   • Das SDK bietet Funktionen und Klassen, die die Einrichtung und Verwaltung dieser Komponenten erleichtern.
   • Sie können die Julep CLI verwenden, um direkt von Ihrem Terminal aus mit der Julep-Plattform zu interagieren.

2. Julep-Backend-Service:

   • Das SDK kommuniziert über das Netzwerk mit dem Julep-Backend.
   • Die CLI kommuniziert über das SDK mit dem Julep-Backend.
   • Das Backend übernimmt die Ausführung von Aufgaben, verwaltet den Sitzungszustand, speichert Dokumente und orchestriert Workflows.

3. Integration mit Tools und APIs:

   • Innerhalb Ihrer Workflows können Sie externe Tools und Dienste integrieren.
   • Das Backend erleichtert diese Integrationen, sodass Ihre Agenten beispielsweise Websuchen durchführen, auf Datenbanken zugreifen oder Drittanbieter-APIs aufrufen können.

📦 Installation

  npm install @julep/sdk

  # or

  bun add @julep/sdk

  pip install julep

🛠️ Julep CLI

Die Julep CLI ist ein Befehlszeilentool, das Ihnen die direkte Interaktion mit der Julep-Plattform von Ihrem Terminal aus ermöglicht. Es bietet eine bequeme Möglichkeit, Ihre AI-Workflows, Aufgaben und Agenten zu verwalten, ohne Code schreiben zu müssen.

pip install julep-cli

Weitere Details finden Sie in der Julep CLI-Dokumentation.

[!NOTE] Die CLI befindet sich derzeit in der Beta-Phase und ist nur für Python verfügbar. Node.js-Unterstützung folgt bald!

🚀 Schnellstart

Stellen Sie sich einen Research-AI-Agenten vor, der Folgendes kann:

1. Ein Thema aufnehmen,
2. 30 Suchanfragen zu diesem Thema generieren,
3. Diese Websuchen parallel durchführen,
4. Die Ergebnisse zusammenfassen,
5. Die Zusammenfassung an Discord senden.

[!NOTE] In Julep wäre dies eine einzelne Aufgabe mit weniger als 80 Codezeilen und würde vollständig verwaltet eigenständig ausgeführt. Alle Schritte werden auf den Servern von Julep ausgeführt, ohne dass Sie eingreifen müssen.

Hier ist ein vollständiges Beispiel für eine Aufgabendefinition:

# yaml-language-server: $schema=https://raw.githubusercontent.com/julep-ai/julep/refs/heads/dev/schemas/create_task_request.json
name: Research Agent
description: A research assistant that can search the web and send the summary to Discord
########################################################
####################### INPUT ##########################
########################################################

# Define the input schema for the task
input_schema:
  type: object
  properties:
    topic:
      type: string
      description: The main topic to research
    num_questions:
      type: integer
      description: The number of search queries to generate

########################################################
####################### TOOLS ##########################
########################################################

# Define the tools that the agent can use
tools:
  - name: web_search
    type: integration
    integration:
      provider: brave
      setup:
        api_key: "<your-brave-api-key>"

  - name: discord_webhook
    type: api_call
    api_call:
      url: https://discord.com/api/webhooks/<your-webhook-id>/<your-webhook-token>
      method: POST
      headers:
        Content-Type: application/json

########################################################
####################### MAIN WORKFLOW #################
########################################################

# Special variables:
# - steps[index].input: for accessing the input to the step at that index
# - steps[index].output: for accessing the output of the step at that index
# - _: for accessing the output of the previous step

# Define the main workflow
main:
# Step 0: Generate search queries
- prompt:
    - role: system
      content: >-
        $ f"""
        You are a research assistant.
        Generate {{steps[0].input.num_questions|default(30, true)}} diverse search queries related to the topic:
        {steps[0].input.topic}

        Write one query per line.
        """
  unwrap: true

# Step 1: Evaluate the search queries using a simple python expression
- evaluate:
    search_queries: $ _.split(NEWLINE)

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

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

# Step 4: Summarize the results
- prompt:
    - role: system
      content: >
        $ f"""
        You are a research summarizer. Create a comprehensive summary of the following research results on the topic {steps[0].input.topic}.
        The summary should be well-structured, informative, and highlight key findings and insights. Keep the summary concise and to the point.
        The length of the summary should be less than 150 words.
        Here are the search results:
        {_.search_results}
        """
  unwrap: true
  settings:
    model: gpt-4o-mini

# Step 5: Send the summary to Discord
- evaluate:
    discord_message: |-
      $ f'''
      **Research Summary for {steps[0].input.topic}**
      {_}
      '''

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

Hier können Sie den obigen Workflow mit dem Julep SDK ausführen:

from julep import Client
import yaml
import time

# Initialize the client
client = Client(api_key=JULEP_API_KEY)

# Create the agent
agent = client.agents.create(
  name="Julep Browser Use Agent",
  description="A Julep agent that can use the computer tool to interact with the browser.",
)

# Load the task definition
with open('./research_agent.yaml', 'r') as file:
  task_definition = yaml.safe_load(file)

# Create the task
task = client.tasks.create(
  agent_id=agent.id,
  **task_definition
)

# Create the execution
execution = client.executions.create(
    task_id=task.id,
    input={
        "topic": "artificial intelligence",
        "num_questions": 30
    }
)

# Wait for the execution to complete
while (result := client.executions.get(execution.id)).status not in ['succeeded', 'failed']:
    print(result.status)
    time.sleep(1)

# Print the result
if result.status == "succeeded":
    print(result.output)
else:
    print(f"Error: {result.error}")

import { Julep } from '@julep/sdk';
import yaml from 'yaml';
import fs from 'fs';

// Initialize the client
const client = new Julep({
  apiKey: 'your_julep_api_key'
});

// Create the agent
const agent = await client.agents.create({
  name: "Julep Browser Use Agent",
  description: "A Julep agent that can use the computer tool to interact with the browser.",
});

// Parse the task definition
const taskDefinition = yaml.parse(fs.readFileSync('./research_agent.yaml', 'utf8'));

// Create the task
const task = await client.tasks.create(
  agent.id,
  taskDefinition
);

// Create the execution
const execution = await client.executions.create(
  task.id,
  {
    input: { 
      "topic": "artificial intelligence",
      "num_questions": 30
    }
  }
);

// Wait for the execution to complete
let result;
while (true) {
  result = await client.executions.get(execution.id);
  if (result.status === 'succeeded' || result.status === 'failed') break;
  console.log(result.status);
  await new Promise(resolve => setTimeout(resolve, 1000));
}

// Print the result
if (result.status === 'succeeded') {
  console.log(result.output);
} else {
  console.error(`Error: ${result.error}`);
}

In diesem Beispiel verwaltet Julep automatisch parallele Ausführungen, wiederholt fehlgeschlagene Schritte, sendet API-Anfragen erneut und hält die Aufgaben zuverlässig bis zum Abschluss am Laufen.

Dies läuft in weniger als 30 Sekunden und liefert folgende Ausgabe:

Was kommt als Nächstes?

• 📚 Entdecken Sie weitere Beispiele in unserem Cookbook
• 🔧 Erfahren Sie mehr über Tool-Integration
• 🧠 Verstehen Sie Agentenspeicher
• 🔄 Tauchen Sie ein in Komplexe Workflows

[!TIP] 💡 Sehen Sie sich weitere Tutorials im Tutorials-Abschnitt der Dokumentation an.

💡 Wenn Sie Anfänger sind, empfehlen wir, mit dem Schnellstart-Leitfaden zu beginnen.

💡 Wenn Sie nach weiteren Ideen suchen, werfen Sie einen Blick in den Ideens-Abschnitt des Repositorys.

💡 Wenn Sie eher an Rezepten im Kochbuch-Stil interessiert sind, sehen Sie sich den Cookbook-Abschnitt des Repositorys an.

🔍 Referenz

📚 SDK-Referenz

• Node.js SDK-Referenz | NPM-Paket
• Python SDK-Referenz | PyPI-Paket

🛠️ API-Referenz

Erkunden Sie unsere API-Dokumentation, um mehr über Agenten, Aufgaben, Tools und die Julep CLI zu erfahren: API-Referenz

💻 Lokales Setup

1. Repository klonen

Klonen Sie das Repository von Ihrer bevorzugten Quelle:

git clone <repository_url>

2. Zum Stammverzeichnis navigieren

Wechseln Sie in das Stammverzeichnis des Projekts:

cd <repository_root>

3. Umgebungsvariablen einrichten

• Erstellen Sie eine .env-Datei im Stammverzeichnis.
• Orientieren Sie sich an der .env.example-Datei für eine Liste der erforderlichen Variablen.
• Stellen Sie sicher, dass alle notwendigen Variablen in der .env-Datei gesetzt sind.

4. Docker-Volume für Backups erstellen

Erstellen Sie ein Docker-Volume namens grafana_data, memory_store_data, temporal-db-data, prometheus_data, seaweedfs_data:

docker volume create grafana_data
docker volume create memory_store_data
docker volume create temporal-db-data
docker volume create prometheus_data
docker volume create seaweedfs_data

5. Projekt mit Docker Compose starten

Sie können das Projekt in zwei verschiedenen Modi ausführen: Single Tenant oder Multi-Tenant. Wählen Sie einen der folgenden Befehle basierend auf Ihren Anforderungen:

1. Single-Tenant-Modus

Starten Sie das Projekt im Single-Tenant-Modus:

docker compose --env-file .env --profile temporal-ui --profile single-tenant --profile self-hosted-db --profile blob-store --profile temporal-ui-public up --build --force-recreate --watch

Hinweis: Im Single-Tenant-Modus können Sie direkt mit dem SDK interagieren, ohne einen API-Schlüssel zu benötigen.

2. Multi-Tenant-Modus

Starten Sie das Projekt im Multi-Tenant-Modus:

docker compose --env-file .env --profile temporal-ui --profile multi-tenant --profile embedding-cpu --profile self-hosted-db --profile blob-store --profile temporal-ui-public up --force-recreate --build --watch

Hinweis: Im Multi-Tenant-Modus müssen Sie lokal ein JWT-Token generieren, das als API-Schlüssel fungiert, um mit dem SDK zu interagieren.

JWT-Token generieren (Nur für Multi-Tenant-Modus)

Um ein JWT-Token zu generieren, wird jwt-cli benötigt. Bitte installieren Sie dies, bevor Sie mit den nächsten Schritten fortfahren.

Verwenden Sie den folgenden Befehl und ersetzen Sie JWT_SHARED_KEY durch den entsprechenden Schlüssel aus Ihrer .env-Datei, um ein JWT-Token zu generieren:

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

Dieser Befehl generiert ein JWT-Token, das für 10 Tage gültig ist.

6. Interaktion

• Temporal UI: Sie können über den in Ihrer .env-Datei angegebenen Port auf die Temporal UI zugreifen.
• Julep SDK: Das Julep SDK ist eine Python/Node.js-Bibliothek, die Ihnen die Interaktion mit der Julep API ermöglicht.

from julep import Client

client = Client(api_key="your_jwt_token")

Hinweis: Im Multi-Tenant-Modus müssen Sie beim Initialisieren des Clients die Umgebung auf local_multi_tenant setzen und den API-Schlüssel auf das im vorherigen Schritt generierte JWT-Token setzen. Im Single-Tenant-Modus können Sie direkt mit dem SDK interagieren, ohne einen API-Schlüssel zu benötigen, und die Umgebung auf local setzen.

7. Fehlerbehebung

• Stellen Sie sicher, dass alle erforderlichen Docker-Images verfügbar sind.
• Überprüfen Sie die .env-Datei auf fehlende Umgebungsvariablen.
• Verwenden Sie den Befehl docker compose logs, um detaillierte Logs zur Fehlerbehebung anzuzeigen.

👥 Mitwirkende

Werden Sie Teil unserer Community! 🌟

Wir freuen uns, neue Mitwirkende im Julep-Projekt willkommen zu heißen! Wir haben mehrere "good first issues" erstellt, um Ihnen den Einstieg zu erleichtern.

Wie Sie mitwirken können:

1. 📖 Lesen Sie unsere CONTRIBUTING.md-Datei für Richtlinien
2. 🔍 Durchsuchen Sie unsere good first issues
3. 💬 Treten Sie unserem Discord bei, um Hilfe und Diskussionen zu erhalten

Ihre Beiträge, groß oder klein, sind für uns wertvoll. Lassen Sie uns gemeinsam etwas Großartiges aufbauen! 🚀

Unsere großartigen Mitwirkenden:

📄 Lizenz

Julep ist unter der Apache License 2.0 lizenziert.

Weitere Details finden Sie in der LICENSE-Datei.