.topbar-cta-button, #topbar-cta-button, .topbar-cta-button a, #topbar-cta-button a {
  background: linear-gradient(135deg, #25A18E 0%, #00A5CF 100%) !important;
  color: #ffffff !important;
  font-weight: 700;
  text-transform: uppercase;
  letter-spacing: 0.5px;
  padding: 0.32rem 1rem !important;
  border-radius: 8px !important;
  position: relative;
  overflow: hidden;
  transition: transform 0.15s ease-in-out;
  box-shadow: 0 3px 8px rgba(0, 165, 207, 0.35);
  animation: julep-cta-pulse 3.5s infinite;
}

.topbar-cta-button:hover {
  transform: translateY(-2px);
  box-shadow: 0 6px 16px rgba(0, 165, 207, 0.55);
}

@keyframes julep-cta-pulse {
  0% {
    box-shadow: 0 0 0 0 rgba(0, 165, 207, 0.5);
  }
  70% {
    box-shadow: 0 0 0 12px rgba(0, 165, 207, 0);
  }
  100% {
    box-shadow: 0 0 0 0 rgba(0, 165, 207, 0);
  }
}

// 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();
}

Delete a secret.

Args:
    secret_id: ID of the secret to delete
    x_developer_id: ID of the developer who owns the secret

Returns:
    The deleted secret

Raises:
    HTTPException: If the secret doesn't exist

Delete Developer Secret

Location

Message

Error Type

ValidationError

APIKeyHeader

ResourceDeletedResponse

HTTPValidationError

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

Overview of the repository structure and key resources for Julep developers

Developer Orientation

Getting Started

Commands for managing Julep projects and resources

Command Reference

Organizational units for grouping related resources

Projects

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)

Files

Understanding Task Executions and Their Lifecycle

Executions

Securely store and manage sensitive information for your LLM applications

Secrets

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

Trip Planning

Define the input schema for the trip planning task

Trip Planning - Input

Configure tools for fetching weather and attraction data

Trip Planning - Tools

Learn the step-by-step workflow for generating itineraries

Trip Planning - Workflow

Execute the task and review the example output

Trip Planning - Running

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 process and analyze videos using Julep

Video Processing

Supported Integrations

Comprehensive guide to AI models and parameters supported by Julep

Supported Models

Guidelines for contributing new integrations to Julep

Add New Integrations

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 how to use Jinja2 templates to create dynamic system prompts for your AI agents

System Templates

Learn about file handling and management in Julep

Files (Multimedia)

Advanced techniques for managing sensitive information in Julep

Secrets Management

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

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

Chat with an Agent

Learn how to create and execute a Julep task

Create & Execute a Julep Task

A practical guide to managing and using secrets in your Julep applications

Using Secrets in Julep

Adding a Tool Integration

Modifying Agent Workflow

Getting started with Julep SDKs for Python and Node.js

Introduction

List all available models that can be used with agents.

Returns:
    ListModelsResponse: A list of available models

List Models

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 or StreamingResponse: The chat response or streaming 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

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

SSE endpoint that streams the status of a given execution_id by polling the
latest_executions view.

Stream Execution Status

Stream Transitions Events

List all secrets for a developer.

Args:
    x_developer_id: ID of the developer whose secrets to list
    limit: Maximum number of secrets to return
    offset: Number of secrets to skip

Returns:
    List of secrets

List Developer Secrets

Create a new secret for a developer.

Args:
    developer_id: ID of the developer creating the secret
    secret: Secret to create

Returns:
    The created secret

Raises:
    HTTPException: If a secret with this name already exists (409 Conflict)

Create Developer Secret

Update a developer secret.

Args:
    developer_id: ID of the developer who owns the secret
    secret_id: ID of the secret to update
    data: New secret data

Returns:
    The updated secret

Raises:
    HTTPException: If the secret doesn't exist or doesn't belong to the developer

Update Developer Secret

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.

agents

sessions

users

files

docs

tasks

executions

secrets

temporal

projects

jobs

healthz

Delete Developer Secret

Authorizations

Path Parameters

Response