Translation Not Available Yet

 

     

Discord · 𝕏 · LinkedIn

🎉 Anúncio: API de Respostas Abertas do Julep (Alpha)

Julep é uma plataforma serverless que ajuda equipes de dados e ML a construir fluxos de trabalho sofisticados de IA. Ele fornece uma base robusta para orquestrar operações complexas de IA, gerenciar estados entre interações e integrar-se à sua infraestrutura e ferramentas de dados existentes.

Seja você esteja construindo pipelines de dados ou criando fluxos de trabalho de IA, o Julep facilita a composição e escalonamento de fluxos de trabalho alimentados por LLM sem gerenciar infraestrutura. Imagine que você queira construir um agente de IA que possa fazer mais do que apenas responder perguntas simples - ele precisa lidar com tarefas complexas, lembrar interações passadas e talvez até usar outras ferramentas ou APIs. É aí que o Julep entra. Nossa plataforma cuida do trabalho pesado para que você possa se concentrar em construir soluções inteligentes para seu negócio.

💡 Para saber mais sobre o Julep, confira a Documentação.

📖 Índice

• ✨ Principais Recursos
• 🧠 Modelo Mental
• 📦 Instalação
  • 🛠️ SDKs do Julep
  • 🛠️ CLI do Julep
• 🚀 Início Rápido
  • O Que Vem Depois?
• 🔍 Referência
  • 📚 Referência do SDK
  • 🛠️ Referência da API
• 💻 Configuração Local
  • 1. Clone o Repositório
  • 2. Navegue até o Diretório Raiz
  • 3. Configure Variáveis de Ambiente
  • 4. Crie um Volume Docker para Backup
  • 5. Execute o Projeto usando Docker Compose
  • 6. Interação
  • 7. Solução de Problemas
• 👥 Contribuidores
  • Junte-se à Nossa Comunidade! 🌟
• 📄 Licença

✨ Principais Recursos

💡 Para saber mais sobre o Julep, confira a Documentação.

🧠 Modelo Mental

O Julep é composto pelos seguintes componentes:

• Plataforma Julep: A plataforma Julep é um serviço em nuvem que executa seus fluxos de trabalho. Ela inclui uma linguagem para descrever fluxos de trabalho, um servidor para executá-los e um SDK para interagir com a plataforma.
• SDKs do Julep: Os SDKs do Julep são um conjunto de bibliotecas para construir fluxos de trabalho. Existem SDKs para Python e JavaScript, com mais em desenvolvimento.
• CLI do Julep: O CLI do Julep é uma ferramenta de linha de comando que permite interagir diretamente com a plataforma Julep a partir do seu terminal.
• API do Julep: A API do Julep é uma API RESTful que você pode usar para interagir com a plataforma Julep.

Pense no Julep como uma plataforma que combina componentes client-side e server-side para ajudá-lo a construir agentes de IA avançados. Veja como visualizá-lo:

1. Seu Código de Aplicação:

   • Você pode usar o SDK do Julep em sua aplicação para definir agentes, tarefas e fluxos de trabalho.
   • O SDK fornece funções e classes que facilitam a configuração e gerenciamento desses componentes.
   • Você pode usar o CLI do Julep para interagir diretamente com a plataforma Julep a partir do seu terminal.

2. Serviço Backend do Julep:

   • O SDK se comunica com o backend do Julep pela rede.
   • O CLI se comunica com o backend do Julep via SDK.
   • O backend cuida da execução de tarefas, mantém o estado da sessão, armazena documentos e orquestra fluxos de trabalho.

3. Integração com Ferramentas e APIs:

   • Dentro de seus fluxos de trabalho, você pode integrar ferramentas e serviços externos.
   • O backend facilita essas integrações, permitindo que seus agentes realizem buscas na web, acessem bancos de dados ou chamem APIs de terceiros.

📦 Instalação

  npm install @julep/sdk

  # or

  bun add @julep/sdk

  pip install julep

🛠️ CLI do Julep

O CLI do Julep é uma ferramenta de linha de comando que permite interagir diretamente com a plataforma Julep a partir do seu terminal. Ele fornece uma maneira conveniente de gerenciar seus fluxos de trabalho de IA, tarefas e agentes sem precisar escrever código.

pip install julep-cli

Para mais detalhes, confira a Documentação do CLI do Julep.

[!NOTE] O CLI está atualmente em beta e disponível apenas para Python. Suporte para Node.js em breve!

🚀 Início Rápido

Imagine um agente de pesquisa de IA que pode fazer o seguinte:

1. Receber um tópico,
2. Criar 30 consultas de pesquisa para esse tópico,
3. Realizar essas buscas na web em paralelo,
4. Resumir os resultados,
5. Enviar o resumo para o Discord.

[!NOTE] No Julep, isso seria uma única tarefa com menos de 80 linhas de código e executada totalmente gerenciada por conta própria. Todas as etapas são executadas nos próprios servidores do Julep e você não precisa fazer nada.

Aqui está um exemplo completo de definição de tarefa:

# 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

Aqui você pode executar o fluxo de trabalho acima usando o SDK do Julep:

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}`);
}

Neste exemplo, o Julep gerenciará automaticamente execuções paralelas, repetirá etapas com falha, reenviará requisições de API e manterá as tarefas em execução de forma confiável até a conclusão.

Isso é executado em menos de 30 segundos e retorna o seguinte resultado:

O Que Vem Depois?

• 📚 Explore mais exemplos em nosso Cookbook
• 🔧 Aprenda sobre Integração de Ferramentas
• 🧠 Entenda Memória do Agente
• 🔄 Mergulhe em Fluxos de Trabalho Complexos

[!TIP] 💡 Confira mais tutoriais na seção Tutoriais da documentação.

💡 Se você é iniciante, recomendamos começar com o Guia de Início Rápido.

💡 Se você está procurando mais ideias, confira a seção Ideias do repositório.

💡 Se você prefere receitas no estilo cookbook, confira a seção Cookbook do repositório.

🔍 Referência

📚 Referência do SDK

• Node.js Referência do SDK | Pacote NPM
• Python Referência do SDK | Pacote PyPI

🛠️ Referência da API

Explore nossa documentação da API para saber mais sobre agentes, tarefas, ferramentas e o CLI do Julep aqui: Referência da API

💻 Configuração Local

1. Clone o Repositório

Clone o repositório da sua fonte preferida:

git clone <repository_url>

2. Navegue até o Diretório Raiz

Mude para o diretório raiz do projeto:

cd <repository_root>

3. Configure Variáveis de Ambiente

• Crie um arquivo .env no diretório raiz.
• Consulte o arquivo .env.example para uma lista de variáveis necessárias.
• Certifique-se de que todas as variáveis necessárias estão definidas no arquivo .env.

4. Crie um Volume Docker para Backup

Crie um volume Docker chamado 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. Execute o Projeto usando Docker Compose

Você pode executar o projeto em dois modos diferentes: Single Tenant ou Multi-Tenant. Escolha um dos seguintes comandos com base na sua necessidade:

1. Modo Single-Tenant

Execute o projeto no modo single-tenant:

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

Nota: No modo single-tenant, você pode interagir com o SDK diretamente sem a necessidade da API KEY.

2. Modo Multi-Tenant

Execute o projeto no modo multi-tenant:

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

Nota: No modo multi-tenant, você precisa gerar um token JWT localmente que atua como uma API KEY para interagir com o SDK.

Gere um Token JWT (Apenas para Modo Multi-Tenant)

Para gerar um token JWT, jwt-cli é necessário. Por favor, instale-o antes de prosseguir com os próximos passos.

Use o seguinte comando e substitua JWT_SHARED_KEY pela chave correspondente do seu arquivo .env para gerar um token JWT:

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

Este comando gera um token JWT que será válido por 10 dias.

6. Interação

• Temporal UI: Você pode acessar a UI Temporal através da porta especificada no seu arquivo .env.
• SDK do Julep: O SDK do Julep é uma biblioteca Python/Node.js que permite interagir com a API do Julep.

from julep import Client

client = Client(api_key="your_jwt_token")

Nota: No SDK em modo multi-tenant, você precisa gerar um token JWT localmente que atua como uma API KEY para interagir com o SDK. Além disso, ao inicializar o cliente, você precisará definir o ambiente como local_multi_tenant e a api key como o token JWT gerado na etapa anterior. Já no modo single-tenant, você pode interagir com o SDK diretamente sem a necessidade da API KEY e definir o ambiente como local.

7. Solução de Problemas

• Certifique-se de que todas as imagens Docker necessárias estão disponíveis.
• Verifique se há variáveis de ambiente ausentes no arquivo .env.
• Use o comando docker compose logs para visualizar logs detalhados para depuração.

👥 Contribuidores

Junte-se à Nossa Comunidade! 🌟

Estamos animados em receber novos contribuidores para o projeto Julep! Criamos várias "boas primeiras issues" para ajudá-lo a começar.

Como Contribuir:

1. 📖 Confira nosso arquivo CONTRIBUTING.md para diretrizes
2. 🔍 Navegue por nossas boas primeiras issues
3. 💬 Junte-se ao nosso Discord para ajuda e discussões

Suas contribuições, grandes ou pequenas, são valiosas para nós. Vamos construir algo incrível juntos! 🚀

Nossos Incríveis Contribuidores:

📄 Licença

O Julep está licenciado sob a Licença Apache 2.0.

Consulte o arquivo LICENSE para obter mais detalhes.