// scripts/entelligence-chat.js
function injectShadowStyles(interval) {
  const container = document.getElementById("entelligence-chat-root");
  if (container && container.shadowRoot) {    
    const shadow = container.shadowRoot;
    const widgetContainer = document.createElement("div");
    shadow.appendChild(widgetContainer);
    
    fetch("https://dujj2xy9pc7vi.cloudfront.net/entelligence-chat.css")
      .then(r => r.text())
      .then(styles => {
        const style = document.createElement("style");        
        style.textContent = styles;
        shadow.prepend(style);
        document.head.prepend(style.cloneNode(true));
      });
    clearInterval(interval);
  }
}
 
function initEntelligence() {
  const script = document.getElementById("entelligence-chat");
 
  if (!script) {
    const chatScript = document.createElement("script");
    chatScript.type = "module";
    chatScript.id = "entelligence-chat";
    chatScript.src = "https://dujj2xy9pc7vi.cloudfront.net/vanilla/entelligence-chat.es.js";
    chatScript.defer = true;
 
    const initScript = document.createElement("script");
    initScript.type = "module";
    initScript.textContent = `
      window.EntelligenceChat.init({
        analyticsData: {
          repoName: "julep",
          organization: "julep-ai",
          apiKey: "-QPa1vq4X-2-KwLus5GxhDBE71g5BdXKwZs2M3iPh8U",
          theme: 'dark',
          companyName: "Julep AI"
        }
      });
    `;
 
    const head = document.getElementsByTagName("head")[0];
    head.appendChild(chatScript);
 
    chatScript.onload = () => {
      document.head.appendChild(initScript);
      const interval = setInterval(() => {
        injectShadowStyles(interval);
      }, 1000);
    };
  }
}
 
if (document.readyState === "loading") {
  document.addEventListener("DOMContentLoaded", initEntelligence);
} else {
  initEntelligence();
}

Quick Solutions

Ready-to-use solutions for common use cases

Authorization

🚨 Open Responses API (Alpha). Learn more [here](/responses/quickstart)

Julep

Welcome to Julep

Step-by-step installation instructions for different environments

Installation

Quick Start

Getting Started

Commands for managing Julep projects and resources

Command Reference

Understanding Julep Agents and their capabilities

Agents

Tasks

Understanding Julep Sessions and state management

Sessions

Tools

Understanding and Managing Users in Julep

Users

Documents (RAG)

Understanding Task Executions and Their Lifecycle

Executions

Learn how to use Julep browser automation capabilities

Browser Use

Learn how to build a RAG chatbot for a website with Julep

RAG Chatbot for Website

Learn how to create a task that generates personalized travel itineraries based on weather conditions and tourist attractions for multiple locations

Trip Planning

Learn how to process and analyze videos using Julep

Video Processing

Comprehensive guide to AI models and parameters supported by Julep

Supported Models

Supported Integrations

Guidelines for contributing new integrations to Julep

Add New Integrations

Learn how to use the Email integration with Julep

Email (SMTP)

OpenWeatherMap

Learn how to use the LlamaParse integration with Julep

LlamaParse

Learn how to use the FFmpeg integration with Julep

FFmpeg

Learn how to use the Cloudinary integration with Julep

Cloudinary

Learn how to use the Unstructured.io integration with Julep

Unstructured

Learn how to use the ArXiv integration with Julep

ArXiv

Learn how to use the Algolia search integration with Julep

Algolia

Learn how to use the Brave integration with Julep

Brave

Learn how to use the Wikipedia integration with Julep

Wikipedia

Learn how to use the Browser Base integration with Julep

Browser Base

Learn how to use the Spider Crawler integration with Julep

Spider Crawler

Learn how to use the Remote Browser integration with Julep

Remote Browser

Learn about the new workflow syntax and how to migrate your existing workflows

New Syntax (Important)

Learn how to use Python expressions in Julep task definitions

Python Expression

Learn about different types of task steps and their use

Types of Task Steps

Learn about the robust chat system and its various features for dynamic interaction with agents

Chat Features in Julep

Learn about the render endpoint for previewing chat inputs before sending them to the model

Render Endpoint in Julep

Learn about file handling and management in Julep

Files (Multimedia)

Understand the core architecture and components of Julep

Architecture Deep Dive

Learn about common patterns and best practices for building Julep agents

Agentic Patterns

Understanding the Lifecycle of Task when executed in Julep

Execution Lifecycle

Learn how to manage complex multi-agent systems with multiple users

Multi-Agent Multi-User Sessions

Local Setup

Chat with an Agent

Learn how to create and execute a Julep task

Create & Execute a Julep Task

Learn how to integrate tools with your Julep agent

Tool Integration Demo

Building a customer service agent with Julep

Customer Service

Research Assistant

Document Processing

Data Analysis

Multi-Agent Systems

Complex Workflows

Common patterns for integrating with external services

Integration Patterns

Industry Solutions

Community Examples

Get started with Julep Open Responses API for LLM interactions

Quickstart

Concepts

Examples of using Julep Open Responses API

Examples

CLI for setting up and using Open Responses API

Roadmap

Getting started with Julep SDKs for Python and Node.js

Introduction

Installation & Setup

Learn how to use tools and integrations with the Python SDK

Tools & Integration

Advanced patterns and best practices for the Python SDK

Advanced Usage

Complete reference documentation for the Python SDK

Python SDK Reference

Add powerful capabilities to your agents with tools

Tools Integration

Advanced patterns and best practices for the Node.js SDK

Complete reference documentation for the Node.js SDK

Node.js SDK Reference

Best practices for handling errors in Julep SDKs

Error Handling

Authentication

Testing patterns and best practices for Julep SDK implementations

Testing

List Agents

Create Agent

List Agent Tools

Create Agent Tool

Get Agent Details

Update Agent

Create Or Update Agent

Delete Agent

Patch Agent

Update Agent Tool

Delete Agent Tool

Patch Agent Tool

Renders a chat input.

Parameters:
    developer (Developer): The developer associated with the chat session.
    session_id (UUID): The unique identifier of the chat session.
    chat_input (ChatInput): The chat input data.

Returns:
    RenderResponse: The rendered chat input.

Render

Initiates a chat session.

Parameters:
    developer (Developer): The developer associated with the chat session.
    session_id (UUID): The unique identifier of the chat session.
    chat_input (ChatInput): The chat input data.
    background_tasks (BackgroundTasks): The background tasks to run.
    x_custom_api_key (Optional[str]): The custom API key.

Returns:
    ChatResponse: The chat response.

Chat

Get Session

Update Session

Create Or Update Session

Delete Session

Patch Session

List Sessions

Create Session

Get Session History

Get User Details

Update User

Create Or Update User

Delete User

Patch User

List Users

Create User

Get Job Status

List Files

Create File

Get File

Delete File

List Agent Docs

Create Agent Doc

Bulk delete documents owned by an agent based on metadata filter

Bulk Delete Agent Docs

List User Docs

Creates a new document for a user.

Parameters:
    user_id (UUID): The unique identifier of the user associated with the document.
    data (CreateDocRequest): The data to create the document with.
    x_developer_id (UUID): The unique identifier of the developer associated with the document.

Returns:
    Doc: The created document.

Create User Doc

Bulk delete documents owned by a user based on metadata filter

Bulk Delete User Docs

Delete Agent Doc

Delete User Doc

Embed

Get Doc

Searches for documents associated with a specific user.

Parameters:
    x_developer_id (UUID): The unique identifier of the developer associated with the user.
    search_params (TextOnlyDocSearchRequest | VectorDocSearchRequest | HybridDocSearchRequest): The parameters for the search.
    user_id (UUID): The unique identifier of the user associated with the documents.

Returns:
    DocSearchResponse: The search results.

Search User Docs

Searches for documents associated with a specific agent.

Parameters:
    x_developer_id (UUID): The unique identifier of the developer associated with the agent.
    search_params (TextOnlyDocSearchRequest | VectorDocSearchRequest | HybridDocSearchRequest): The parameters for the search.
    agent_id (UUID): The unique identifier of the agent associated with the documents.

Returns:
    DocSearchResponse: The search results.

Search Agent Docs

Create Or Update Task

List Tasks

Create Task

List Task Executions

Get Task Details

Get Execution Transition

Create Task Execution

Get Execution Details

Update Execution

List Execution Transitions

Stream Transitions Events

Decodes a list of payloads from the request body.

Args:
    req (Request): The request containing the payloads to decode.

Returns:
    dict: A dictionary containing the decoded payloads, including any errors encountered.

​Quick Solutions

Quick Solutions