Julep AI: uma plataforma de nuvem de IA para criar fluxos de trabalho corporais inteligentes em várias etapas usando DSLs

Introdução geral

O Julep AI é uma plataforma para criar e gerenciar inteligências de IA que se lembram de interações passadas e executam tarefas complexas de várias etapas. O Julep AI fornece memória de longo prazo e recursos de gerenciamento de processos de várias etapas e oferece suporte à integração com ferramentas e APIs externas, o que permite lidar com cenários complexos. Os usuários podem escrever arquivos YAML simples para definir etapas individuais de uma tarefa, pontos de decisão, loops, processamento paralelo, etc., e automatizar a execução dessas tarefas na nuvem.

O Julep AI apresenta uma nova linguagem específica de domínio (DSL) e um servidor para gerenciar inteligências de IA e tarefas de várias etapas. Essa DSL permite que os usuários descrevam e gerenciem fluxos de trabalho complexos de forma mais intuitiva, sem precisar escrever grandes quantidades de código tradicional. A plataforma de nuvem do Julep AI se encarrega de executar essas tarefas, garantindo que elas sejam confiáveis e eficientes.

Lista de funções

• Agente de IA persistenteInteligência: os inteligentes são capazes de lembrar o contexto e as informações para apoiar a interação de longo prazo.
• sessão completaRastreie interações anteriores para fornecer uma resposta personalizada.
• tarefa de várias etapasCriação de processos complexos de várias etapas por meio de loops e decisões.
• Gerenciamento de tarefasTarefas: lida com tarefas que podem ser executadas por longos períodos de tempo e garante que as tarefas sejam concluídas com êxito.
• Ferramentas incorporadas e integração de APISuporte ao uso de ferramentas integradas e APIs externas para ampliar a funcionalidade das inteligências.
• autocuraTentativa automática de repetir etapas com falha e reenviar a mensagem para garantir que a tarefa seja executada sem problemas.
• RAG (Retrieval Augmentation Generation)Use um armazenamento de documentos para criar um sistema para recuperar e usar seus próprios dados.

Usando a Ajuda

Processo de instalação

1. Registrar uma contaVisite o site da Julep AI, clique no botão "Register" (Registrar) e preencha as informações necessárias para concluir seu registro.
2. Obter chave de APIApós fazer login, localize a opção de geração de chave de API no painel do usuário para gerar e salvar a chave de API.
3. Baixar o SDKDownload do SDK apropriado (por exemplo, Python, Node.js, etc.) de acordo com os requisitos da plataforma e instale-o de acordo com a documentação.

Diretrizes para uso

Criando a Intelligentsia

1. Definição de inteligênciaNo painel de controle, clique em "Create Intelligence" (Criar inteligência) e preencha o nome e a descrição da inteligência.
2. modelo de configuraçãoEscolha um modelo de IA adequado (por exemplo, GPT-4) e defina os parâmetros padrão (por exemplo, temperatura, número máximo de tokens etc.).
3. Adicionar ferramentasAdicionar as ferramentas necessárias para inteligências, como pesquisa na Web, chamadas de API, etc.

Definição de processos em várias etapas

1. Gravação de arquivos YAMLNo painel de controle, escreva um processo de várias etapas usando YAML para definir árvores de decisão, loops e execução paralela.
2. Carregamento de arquivosCarregue o arquivo YAML escrito na plataforma e teste-o.
3. Processo de implantação: Quando o teste for aprovado, clique no botão "Deploy" (Implantar) para colocar o processo on-line.

Prototipagem rápida

1. Criar um novo projetoNo painel de controle, clique em "New Project" (Novo projeto) e preencha o nome e a descrição do projeto.
2. Adicionar módulo de funçãoSelecione e adicione os módulos funcionais necessários (por exemplo, RAG, gerenciamento de status, etc.), conforme necessário.
3. Testes e iteraçãoTestes na plataforma, ajustando e otimizando os módulos funcionais em tempo real.

Preparação do nível de produção

1. Infraestrutura de configuraçãoNo painel de controle, configure as opções de infraestrutura, como dimensionamento automático, balanceamento de carga, etc.
2. Configuração do tratamento de errosDefinição de mecanismos de tratamento de erros para garantir que as tarefas sejam repetidas automaticamente em caso de falha.
3. Projetos on-lineApós concluir a configuração, clique no botão "Go Live" para colocar o projeto em produção.

Design modular

1. Selecionar móduloNo painel de controle, procure e selecione o módulo desejado (por exemplo, conexão API externa, comutação LLM, etc.).
2. integração de arrastar e soltarIntegração de módulos em projetos usando uma interface de arrastar e soltar.
3. Testes e otimizaçãoTeste em tempo real da funcionalidade do módulo para otimização e ajuste.

Expansão ilimitada

1. Configuração de opções estendidasNo Painel de controle, configure as opções Auto Scaling e Load Balancing.
2. Monitoramento do desempenhoMonitorar o desempenho do sistema e a simultaneidade de usuários em tempo real usando as ferramentas de monitoramento fornecidas pela plataforma.
3. Ajuste da configuraçãoAjuste as configurações de expansão e balanceamento de carga com base nos dados de monitoramento para garantir uma operação estável do sistema.

preparação para o futuro

1. Adicionar novo modeloNo Painel de controle, clique em "Add New Model" (Adicionar novo modelo) para selecionar e configurar um novo modelo de IA.
2. Integração de novas ferramentasNavegue pelas novas ferramentas oferecidas pela plataforma, selecione-as e integre-as aos projetos existentes.
3. Testes e implementaçãoTeste de novos modelos e ferramentas para garantir a compatibilidade e a estabilidade e, em seguida, implemente em tempo real.

tarefa de amostra

O Julep é adequado para aplicativos que exigem casos de uso de IA que vão além de modelos simples de resposta a dicas.

Exemplo rápido

Imagine um agente de IA de pesquisa que possa executar as seguintes ações:

• Selecione um tópico
• 30 consultas de pesquisa sobre esse tópico
• Pesquisa simultânea na Web
• Resumo dos resultados
• Enviar resumo para o Discord

No Julep, essa será uma tarefa separada, com 80 linhas de código e, em seguida, executada totalmente hospedada, tudo feito de forma independente. Todas as etapas são executadas nos próprios servidores do Julep, portanto, você não precisa fazer nada.

Esse é um exemplo válido:

nome: Research Agent
# Opcional: Definir o esquema de entrada para a tarefa
input_schema.
type: object
input_schema: tipo: objeto
topic.
tipo: string
descrição: o tópico principal a ser pesquisado
num_questions.
tipo: integer
descrição: o número de consultas de pesquisa a serem geradas.
# Definir as ferramentas que o agente pode usar
tools: name: web_search
- nome: web_search
tipo: integration
integração: web_search
name: web_search type: integration
setup.
api_key: 
- nome: discord_webhook
tipo: api_call
api_call.
url: https://discord.com/api/webhooks//
método: POST
método: POST
Content-Type: application/json
# Variáveis especiais.
# - inputs: para acessar a entrada da tarefa
# - outputs: para acessar a saída das etapas anteriores
# - _: para acessar a saída da etapa anterior
# Defina a função principal fluxo de trabalho
principal.
- prompt.
- função: sistema
conteúdo: >-
Você é um assistente de pesquisa.
Gere {{inputs[0].num_questions|default(30, true)}} diversas consultas de pesquisa relacionadas ao tópico.
{{inputs[0].topic}}

Escreva uma consulta por linha.
Escreva uma consulta por linha. unwrap: true
# Avalie as consultas de pesquisa usando uma expressão python simples
- evaluate.
search_queries: "_.split(NEWLINE)"
# Execute a pesquisa na Web em paralelo para cada consulta
- over: "_.search_queries"
map.
ferramenta: web_search
argumentos.
map: tool: web_search arguments: "_.search_queries" map: tool: web_search
paralelismo: 5
# Coletar os resultados da pesquisa na Web
- Coletar os resultados da pesquisa na Web
search_results: _
# Resumir os resultados
- prompt.
- role: system
content: > Você é um resumidor de pesquisa.
Você é um resumidor de pesquisa. Crie um resumo abrangente dos seguintes resultados de pesquisa sobre o tópico {{inputs[0].topic}}.
O resumo deve ser bem estruturado, informativo e destacar as principais descobertas e percepções. Mantenha o resumo conciso e direto ao ponto.
O resumo deve ter menos de 150 palavras.
O tamanho do resumo deve ser inferior a 150 palavras.
{{_.search_results}}
  Aqui estão os resultados da pesquisa: {{_.search_results}}
Aqui estão os resultados da pesquisa: {{_.search_results}} unwrap: true
modelo: gpt-4o-mini
- evaluate: {{_.search_results}
discord_message: |-
f'''
**Resumo da pesquisa para {inputs[0].topic}**
{_}
'''

# Enviar o resumo para o Discord
- ferramenta: discord_webhook
argumentos: discord_webhook
_.discord_message[:2000] # O Discord tem um limite de 2000 caracteres.
content: _.discord_message[:2000] # O Discord tem um limite de 2000 caracteres

Neste exemplo, o Julep gerenciará automaticamente a execução paralela, tentará novamente as etapas com falha, reenviará as solicitações de API e manterá a tarefa em execução de forma confiável até a conclusão.

Amostra de resultados de saída

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

Resumo da pesquisa sobre inteligência artificial

Resumo dos resultados da pesquisa sobre inteligência artificial (IA)

breve
Nos últimos anos, houve avanços significativos no campo da Inteligência Artificial (IA), caracterizados pelo desenvolvimento de métodos e técnicas que permitem que as máquinas percebam seu ambiente, aprendam com os dados e tomem decisões. Este resumo se concentra nos insights obtidos com várias descobertas de pesquisas relacionadas à IA.

Principais conclusões

• Definição e escopo da inteligência artificial ::
  A inteligência artificial é definida como um ramo da ciência da computação que se concentra na criação de sistemas capazes de executar tarefas que exigem inteligência semelhante à humana, incluindo aprendizado, raciocínio e solução de problemas (Wikipedia). Ela abrange uma variedade de subcampos, incluindo aprendizado de máquina, processamento de linguagem natural, robótica e visão computacional.
• Impacto e aplicação ::
  A tecnologia de IA está sendo integrada em vários campos para aumentar a eficiência e a produtividade. Os aplicativos vão desde carros autônomos e diagnósticos médicos até automação de atendimento ao cliente e previsão financeira (OpenAI). O compromisso do Google de fazer com que a IA funcione para todos destaca seu potencial de melhorar significativamente a vida cotidiana, aprimorando a experiência do usuário em todas as plataformas (Google AI).
• considerações éticas ::
  Há uma discussão em andamento sobre as implicações éticas da IA, incluindo preocupações sobre privacidade, parcialidade e responsabilidade nos processos de tomada de decisão. Foi enfatizada a necessidade de uma estrutura para garantir o uso seguro e responsável das tecnologias de IA (OpenAI).
• Mecanismos de aprendizado ::
  Os sistemas de IA utilizam diferentes mecanismos de aprendizado, como aprendizado supervisionado, aprendizado não supervisionado e aprendizado por reforço. Esses métodos permitem que a IA melhore o desempenho aprendendo com experiências e dados anteriores (Wikipedia). A diferença entre aprendizado supervisionado e não supervisionado é fundamental; o aprendizado supervisionado depende de dados rotulados, enquanto o aprendizado não supervisionado reconhece padrões sem rótulos predefinidos (não supervisionado).
• direção futura ::
  Espera-se que os futuros desenvolvimentos em IA se concentrem no aprimoramento da interpretabilidade e da transparência dos sistemas de IA para garantir que eles sejam capazes de fornecer decisões e ações sólidas (OpenAI). Também estão sendo feitos esforços para tornar os sistemas de IA mais acessíveis e fáceis de usar, incentivando sua adoção mais ampla por diferentes pessoas e setores (Google AI).

chegar a um veredicto
A inteligência artificial representa uma força transformadora em vários domínios, prometendo remodelar os setores e melhorar a qualidade de vida. No entanto, à medida que seus recursos se expandem, é fundamental abordar as implicações éticas e sociais que a acompanham. A pesquisa e a colaboração contínuas entre tecnólogos, especialistas em ética e formuladores de políticas serão fundamentais para navegar no futuro cenário da IA.

Processo de implantação do Python

Para começar a usar o Julep, instale-o usando o pip:

pip install julep

Obtenha sua chave de API aqui.

#### Etapa 0: Configuração

importar tempo
importar yaml
from julep import Julep # ou AsyncJulep

cliente = Julep(api_key="your_julep_api_key")

### Etapa 1: criar um agente

agente = client.agents.create(
name="Storytelling Agent",
name="Storytelling Agent", model="claude-3.5-sonnet",
about="Você é um contador de histórias criativo que cria histórias envolventes sobre uma infinidade de tópicos.",)
)

### Etapa 2: Crie uma tarefa que gere um arquivo história e histórias em quadrinhos

task_yaml = """
nome: Contador de histórias
descrição: criar uma história com base em uma ideia.

name: research_wikipedia
- nome: research_wikipedia
type: integração
integração: research_wikipedia
provedor: wikipedia
método: pesquisa

método: pesquisa
# Etapa 1: Gerar uma ideia de enredo
- prompt.
- função: sistema
conteúdo: Você é {{agent.name}}. {{agent.about}}
- função: usuário
conteúdo: >
Com base na ideia '{{_.idea}}', gere uma lista de 5 ideias de enredo. Seja louco e o mais criativo possível. Retorne seu resultado como uma lista de strings longas dentro de `` A tag `yaml está no final de sua resposta.
Expandir: true

- Avaliação:
Ideias de enredo: load_yaml (_.split('````yaml')[1].split('````')[0].strip()))

# Etapa 2: Extrair áreas de pesquisa das ideias de enredo
- Rapidamente:
- Função: Sistema
Conteúdo: você é {{agent.name}} {{agent.about}}
- Função: Usuário
Conteúdo: >
Aqui estão algumas ideias de enredo:
{% denota ideias em _.plot_ideas %}
- {{ideia}}
{% fim %}

Para desenvolver um enredo, precisamos pesquisar ideias de enredo.
O que devemos pesquisar? Escreva uma consulta de pesquisa na Wikipedia para ideias de enredo que você considere interessantes.
Retorne o resultado como uma lista yaml ```yaml tags no final de sua resposta.
unwrap: true
settings.
modelo: gpt-4o-mini
temperatura: 0,7

- avaliar.
research_queries: load_yaml(_.split('````yaml')[1].split('````')[0].strip())

# Etapa 3: Pesquisar cada ideia de plotagem
- foreach: in: _.research_queries[1][0].strip()
in: _.research_queries
do: in: _.research_queries
tool: research_wikipedia
research_queries do: tool: research_wikipedia
_.research_queries

- evaluate.
wikipedia_results: 'NEWLINE.join([f"- {doc.metadata.title}: {doc.metadata.summary}" for item in _ for doc in item.documents])'

# Etapa 4: Pensar e deliberar
- prompt: {doc.metadata.title}: {doc.metadata.summary}
- função: sistema
content: Você é {{agent.name}}. {{agent.about}}
- função: usuário
conteúdo: |-
Antes de escrevermos a história, vamos pensar e deliberar.
{% for idea in outputs[1].plot_ideas %}
- {{ideia}}
{% endfor %}

Aqui estão os resultados da pesquisa das ideias de enredo na Wikipedia.
{{_.wikipedia_results}}

Pense nas ideias de enredo de forma crítica. Combine as ideias de enredo com os resultados da Wikipedia para criar um enredo detalhado para uma história.
Anote todas as suas anotações e pensamentos.
Por fim, escreva o enredo como um objeto yaml dentro de ```as tags yaml estão localizadas no final da resposta. Os objetos yaml devem ter a seguinte estrutura:

```yaml
título: ""
caracteres.
- nome: ""
sobre: ""
sinopse: ""
cenas.
- título:""
descrição: ""
caracteres.
- nome: ""
função: ""
enredos.
- "" ```

Verifique se o yaml é válido e se as funções e cenas não estão vazias. Também esteja ciente dos pontos e vírgulas e de outros problemas com a escrita do yaml.
expandir: verdadeiro

- Avaliação:
Plot: "load_yaml (_.split('```` yaml')[1].split('````')[0].strip())"
"""

Tarefas = Client. Task. Create (
agent_id = agent.id.
**yaml.safe_load (task_yaml)
)

### Etapa 3: Executar a tarefa

Execute = Client . Execute . Create (
id da tarefa = id da tarefa.
Input = {"idea": "Um gato aprendendo a voar"}
)

# 🎉 Assista à geração da história e do painel de quadrinhos
while (result := client.executions.get(execution.id)).status not in ['success', 'failure']:
Print (result. status, result. Output)
time. Sleep(1)

# 📦 Recuperar o resultado após a conclusão da execução
se result.status == "success":
Print (result. Output)
Outro:
Levantar uma exceção (result. Error)