LANGFLOW

Desenvolvimento Visual de Sistemas

Multi-Agentes com IA Generativa

SANDRO MOREIRA

LANGFLOW 1
 LANGFLOW
Desenvolvimento Visual de Sistemas
Multi-Agentes com IA Generativa

SANDRO MOREIRA

Todos os direitos reservados - 1ª Edição - 2024

Sobre o autor

Sandro Silva Moreira é

desenvolvedor de softwares com mais de
25 anos de experiência, Mestre em
Engenharia Mecânica pela Universide
Estadual Paulista (UNESP), MBA em
Governança de Tecnologia da Informação
pela UNIEURO e Bacharel em Sistemas de
Informação pela Universidade Estadual de
Goiás (UEG). Atua como Gestor de
Tecnologia da Informação e Professor desde
2013 em cursos de Engenharia de Software,
Ciências da Computação e cursos de pós-
graduação da UniRV - Universidade de Rio
Verde e em cursos de pós-graduação da
Universidade Federal de Goiás (UFG). É
pesquisador no Centro de Excelência em
Inteligência Arti cial (CEIA-UFG), Lider da
comunidade Google Developers Group
(GDG) na cidade Rio Verde-GO desde 2015
e Mentor no programa Google for Startups
Brasil desde 2021. Palestrante da área de
Inteligência Arti cial em mais de 90
eventos de tecnologia no Brasil e outros
países da America Latina nos últimos 5
anos. Realiza consultorias e mentorias
ajudando pessoas e empresas a aprenderem
e escolherem as melhores estratégias para
adoção da IA em seus projetos de software.

LANGFLOW 3
fi
fi
 À minha esposa Eveline, minhas lhas Isabela e
Isadora pelo apoio em todos os momentos

LANGFLOW 4
fi
SUMÁRIO

Capítulo 1 - Introdução à IA Generativa ..............................................................08

1.1 - Aprendizado Profundo? Vem que eu te explico! ...............................................11

1.2 - Grandes Modelos de Linguagem (LLM) ...........................................................12

1.3 - Prompts: A chave para um bom resultado de um LLM ....................................14

1.4 - Como eu crio um bom prompt? ........................................................................15

1.5 - API’s e Frameworks ..........................................................................................19

1.6 - No Code VS Low Code .....................................................................................20

Capítulo 2 - IA sem Programar? Sim, é verdade! ................................................22

2.1 - Bem Vindo ao Lang ow! ...................................................................................23

2.2 - Iniciando com Lang ow ....................................................................................24

2.3 - Tour pelo Lang ow ...........................................................................................26

Capítulo 3 - Vamos criar um Chatbot com LLM usando Lang ow? Peque seu
capacete! ..................................................................................................................29

3.1 - Criando uma chave de API da OpenAI .............................................................29

3.2 - Começando o Chatbot ......................................................................................30

3.3 - Componente Chat Input ...................................................................................32

3.4 - Componente Prompt .........................................................................................32

3.5 - Componente OpenAI ........................................................................................33

3.6 - Componente Chat Output ................................................................................34

LANGFLOW 5
fl
fl
fl
fl
3.7 - Playground ........................................................................................................34

3.8 - Gerando uma chave de API do Google Generative AI (Gemini)......................35

3.9 - Componente Google Generative AI (Gemini) ..................................................36

Capítulo 4 - Criando um Redator para seu Blog .................................................40

4.1 - Componente URL .............................................................................................42

4.2 - Componente Parse Data....................................................................................42

4.3 - Componente Text Input ....................................................................................42

4.4 - Customizando o Prompt ...................................................................................43

4.5 - Testando 1, 2, 3 .................................................................................................44

Capítulo 5 - IA com meus próprios dados ............................................................45

5.1 - Geração Aumentada por Recuperação (RAG) ...................................................45

5.2 - Embeddings ......................................................................................................46

5.3 - Componentes Vector Stores ..............................................................................48

Capítulo 6 - Criando um Chatbot com Base em um Arquivo Próprio..............50

Capítulo 7 - Chatbot com RAG com Dados sobre a Dengue..............................54

7.1 - Gravando Nosso Embedding em um Banco de Dados ......................................54

7.2 - Recuperando Dados em nosso Banco de Embeddings ......................................60

7.3 - Testando Tudo ...................................................................................................62

Capítulo 8 - Criação de Componentes no Lang ow: Eu quero Programar! ......65

8.1 - Nosso Próprio Componente de Transcrição de Vídeo.......................................66

8.2 - Criando um Componente de Geração de Imagem no DALL-E .........................70

8.3 - Componente para Salvar o Resultado em um Arquivo .....................................73

8.4 - Uma Super Ajuda na Criação de Componentes Customizados ........................74

Capítulo 9 - Fluxos ou Agentes? ...........................................................................76

9.1 - O que é um Agente? .........................................................................................76

9.2 - Fluxos no Lang ow como Agentes ...................................................................77

9.3 - Características de um Agente em um Fluxo Lang ow .....................................78

LANGFLOW 6
fl
fl
fl
9.4 - Crew AI - Um aliado poderoso! ........................................................................79

9.5 - Planejando seus Agentes ...................................................................................80

9.6 - Criando uma Equipe .........................................................................................82

Capítulo 10 - Criando um Sistema com Múltiplos Agentes ...............................83

10.1 - Agentes Envolvidos .........................................................................................84

10.2 - Tarefas dos Agentes.........................................................................................86

10.3 - Criando os Prompts ........................................................................................88

10.4 - Sequential Crew ..............................................................................................90

Capítulo 12 - Monitorando sua Aplicação com LangWatch ...............................91

Capítulo 11 - Realizando Deploy de Seus Projetos .............................................96

Referências e Links ..................................................................................................101

LANGFLOW 7
 Capítulo 1

Introdução à IA Generativa

Há não muito tempo, o conceito de Inteligência Arti cial (IA) estava quase
exclusivamente associado à cção cientí ca. Obras de autores como Isaac Asimov e
lmes como "Perdidos no Espaço", "A Super Máquina", "O Exterminador do Futuro"
e "The Matrix" moldaram nossa percepção do que a IA poderia ser. Nessas histórias,
a IA frequentemente assumia papéis fantásticos e, por vezes, ameaçadores, gerando
uma série de mitos e especulações sobre seu potencial futuro. Entre esses mitos,
está a ideia de que uma IA poderia se tornar consciente e decidir que precisa se
defender dos humanos, um cenário apocalíptico que sempre volta às discussões
sobre o futuro da tecnologia.

A trajetória da IA é marcada por altos e baixos. Desde as primeiras propostas

nos anos 1950 e os avanços dos anos 1970, houve um período conhecido como
"inverno da IA", onde o progresso foi severamente limitado pelas capacidades de
hardware da época, como memórias e processadores insu cientes. Esse período de
estagnação durou até cerca de 2012. Durante esses anos, os avanços foram mínimos
e a pesquisa em IA parecia ter atingido um impasse.

Foi apenas com a introdução de novos e poderosos algoritmos que as redes

neurais começaram a se expandir e a se tornar mais e cientes. Esse
desenvolvimento marcou o início da Era do Deep Learning. Redes neurais
profundas, compostas por múltiplas camadas de processamento, possibilitaram que
os sistemas de IA aprendessem a partir de grandes volumes de dados de forma mais
e caz, melhorando signi cativamente sua capacidade de realizar tarefas complexas.

Inicialmente, as IAs foram desenvolvidas com propósitos muito especí cos.

Cada IA era projetada para realizar uma tarefa particular e nada mais. Por exemplo,
uma IA criada para classi car e-mails como spam ou não, era incapaz de realizar
qualquer outra função, como corrigir erros gramaticais nesses mesmos e-mails.

LANGFLOW 8
fi
fi
fi
fi
fi
fi
fi
fi
fi
fi
 Dessa forma, muitas IAs foram concebidas para tarefas isoladas como classi cação
de textos, reconhecimento de imagens, identi cação de padrões, previsões baseadas
em séries históricas de dados e detecção de anomalias. Essas IAs eram
essencialmente ferramentas especializadas, sem capacidade de criar ou inovar.

Hoje, estamos entrando em uma nova era com a IA Generativa. Imagine um

mundo onde máquinas não apenas seguem instruções, mas também são capazes de
sonhar, criar e inovar ao lado dos seres humanos. Esse cenário, outrora restrito à
cção cientí ca, está se tornando uma realidade tangível graças aos avanços no
campo da IA Generativa.

Diferente das IAs tradicionais, a IA Generativa não se limita a executar

tarefas especí cas. Em vez disso, ela é projetada para criar novos conteúdos,
gerando ideias e produções originais. Utilizando algoritmos complexos e técnicas de
aprendizado profundo, a IA Generativa está aprendendo a criar imagens cada vez
mais impressionantes, compor músicas emocionantes, escrever poemas tocantes e
até desenvolver códigos e softwares inovadores. Esse tipo de IA é capaz de gerar
arte, música, texto e até mesmo produtos físicos, abrindo um mundo de
possibilidades criativas.

Um dos exemplos mais notáveis da IA Generativa é o GPT (Generative Pre-

trained Transformer), um modelo de linguagem desenvolvido pela OpenAI ou o
Gemini desenvolvido pela Google Inc, uma das iterações mais avançadas, pode gerar
textos com uma impressionante semelhança ao escrito por humanos, completar
frases, responder perguntas e até mesmo escrever ensaios completos. Outro
exemplo é o DALL-E, também da OpenAI, que pode criar imagens originais a partir
de descrições textuais, combinando elementos de maneiras criativas e inéditas.

Na música, a IA Generativa está sendo usada para compor novas melodias e

harmonias. Sistemas como o Magenta, desenvolvido pelo Google podem analisar
grandes volumes de músicas existentes e, a partir disso, criar novas composições.
Na arte, artistas estão colaborando com IAs generativas para criar obras de arte
digitais que exploram novas fronteiras da criatividade.

Como qualquer nova tecnologia, a IA Generativa enfrenta uma série de

desa os. Um dos principais é o problema das "alucinações", onde a IA gera
informações incorretas ou absurdas. Isso ocorre porque a IA se baseia nos dados

LANGFLOW 9
fi
fi
fi
fi
fi
fi
 com os quais foi treinada, e às vezes pode combinar informações de maneiras que
não fazem sentido ou não são precisas. Por exemplo, uma IA treinada em um grande
conjunto de dados de texto pode gerar uma frase que é gramaticalmente correta,
mas factualmente errada.

Além disso, a questão da ética na IA Generativa é um tópico de crescente

preocupação. O uso de IAs para criar conteúdos falsos, como deepfakes, levanta
questões sobre a autenticidade e a con ança na informação. Há também
preocupações sobre a propriedade intelectual, já que a IA pode criar obras que se
assemelham a trabalhos existentes.

Apesar desses desa os, o potencial da IA Generativa é vasto e promissor. À

medida que a tecnologia avança, esperamos ver IAs cada vez mais capazes de
colaborar com humanos de maneiras inovadoras e produtivas. Em campos como
medicina, arquitetura, engenharia e artes, a IA Generativa tem o potencial de
revolucionar a forma como abordamos problemas e criamos soluções.

Em resumo, a IA evoluiu de uma ideia fantasiosa para uma ferramenta

poderosa e criativa que está pronta para transformar diversas áreas de nossas vidas.
A verdadeira revolução não está apenas na automação de tarefas, mas na capacidade
dessas máquinas de sonhar, criar e inovar junto com os seres humanos. À medida
que continuamos a explorar e desenvolver essa tecnologia, é crucial abordar os
desa os éticos e técnicos para garantir que a IA Generativa seja utilizada de maneira
responsável e bené ca para toda a sociedade.

A imagem da capa deste livro foi criada com uma IA Generativa.

LANGFLOW 10
fi
fi
fi
fi
 1.1 - Aprendizado Profundo? Vem que eu te explico!

Imagine uma criança aprendendo a reconhecer um gato. Ele não decora uma
lista de regras como "tem bigodes", "tem quatro patas", "mia". Ao invés disso, ele
observa diversos gatos, absorvendo suas características e nuances até conseguir
diferenciá-los de outros animais.

O aprendizado profundo funciona de maneira similar. Em vez de ser

programado com regras explícitas, um modelo de aprendizado profundo aprende a
partir de grandes quantidades de dados, identi cando padrões complexos e relações
ocultas.

Fonte: NXP Semiconductors

1. Durante o aprendizdo uma rede neural arti cial recebe os dados de

entrada, como imagens, textos ou até mesmo sons

2. A informação se propaga pelas camadas, com cada neurônio realizando

cálculos

3. A saída da rede é comparada com a resposta desejada (por exemplo,

identi car corretamente a imagem do tal gato)

LANGFLOW 11
fi
fi
fi
 4. Os “pesos" das conexões são ajustados automaticamente para minizar o
erro entre a saída da rede e a resposta correta.

Com o tempo e a experiência, ou seja, muito treino com dados, a rede

“aprende" a realizar tarefas complexas como reconhecer objetos, traduzir, gerar
textos semelhantes e coerentes, etc.

Utilizando múltiplas camadas de processamento, as redes neurais profundas

podem abstrair características de alto nível a partir de dados brutos, o que é
essencial para gerar novos conteúdos. Essa capacidade foi catalisada por avanços em
algoritmos, aumento do poder computacional e disponibilidade de grandes volumes
de dados para treinamento.

Como resultado, a IA passou a ser capaz de criar textos, imagens, músicas e

outros tipos de conteúdo de forma autônoma e inovadora, superando as limitações
das abordagens anteriores que se restringiam a tarefas especí cas e pré-de nidas.

1.2 - Grandes Modelos de Linguagem (LLM)

Grandes Modelos de Linguagem (LLMs, do inglês Large Language Models)

são uma categoria de modelos de Inteligência Arti cial que utilizam técnicas de
aprendizado profundo (Deep Learning) para entender e gerar texto de maneira
surpreendentemente similar à linguagem humana. Eles são construídos sobre
arquiteturas de redes neurais bem mais complexas e são treinados em vastos
conjuntos de dados textuais provenientes de diversas fontes, incluindo livros,
artigos, websites e redes sociais.

O objetivo principal dos LLMs é compreender o contexto e a semântica das

palavras em um nível extremamente detalhado, o que lhes permite realizar tarefas
variadas como tradução, sumarização, resposta a perguntas e até mesmo geração de
texto criativo.

LANGFLOW 12
fi
fi
fi
 Como pode imaginar, o termo “Large" não diz respeito apenas a sua grande
capacidade, pois esses modelos acabam-se por tornar grandes em quantidade de
parâmetros que a rede neural precisa calcular e processar, exigindo assim mais
recursos computacionais para serem utilizados.

Com o avanço das arquiteturas de rede neural, especialmente o Transformer

introduzido pelo Google em 2017, foi possível criar modelos com bilhões de
parâmetros que podem capturar nuances complexas da linguagem humana. Estima-
se que o GPT-4 tenha mais de 100 trilhões de parâmetros, um salto gigantesco em
comparação aos 175 bilhões do GPT-3.5. Essa explosão na quantidade de
parâmetros re ete um treinamento alimentado por um volume colossal de dados.

Com tantas opções de modelos LLMs disponíveis, com custos de utilização

variados, alguns disponíveis de maneira Open Source, escolher um modelo
adequado parece ser uma tarefa complicada. Qual é melhor? A quantidade de
parâmetros de ne isso? Não. Determinado modelo pode ter sido treinado com
trilhões de parâmetros mas apenas de um assunto, ou seja, será muito bom em uma
tarefa mas pode ter desempenho pí o em outra tarefa. Precisamos realizar
experimentos para entender se os resultados estão satisfatórios e se podemos
ajustar de acordo com nosso interesse.

LANGFLOW 13
fl
fi
fi
 Na tabela acima podemos visualizar um comparativo dos modelos LLM
realizado pelo projeto LMSYS Chatbot Arena, uma plataforma aberta para avaliações
LLM que coleta mais de 1.000.000 de comparações humanas entre dois modelos
anônimos para classi car o desempenho dos modelos. Extraído em Julho de 2024.
(https://arena.lmsys.org)

Como podemos observar, alguns modelos tem um "Knowledge Cuto ”,

basicamente o limite temporal das informações que foram utilizadas no treinamento
muito longo, outros são em tempo real. Os votos são computados através de um
ambiente onde os usuários fazem qualquer pergunta a dois modelos anônimos e
vota na melhor resposta e os scores como são calculados de acordo com os
parâmetros dados entre as vezes em que o modelo foi experimentado pelo usuário e
seu desempenho. (https://arxiv.org/pdf/2403.04132)

Apesar de suas capacidades avançadas, os LLMs enfrentam desa os e

limitações signi cativas. Um dos principais desa os é o problema das "alucinações",
onde o modelo gera informações que são factualmente incorretas ou incoerentes.
Isso ocorre porque os LLMs baseiam-se nos dados com os quais foram treinados, e
esses dados nem sempre são precisos ou abrangentes. Além disso, os LLMs podem
re etir e até ampli car preconceitos presentes nos dados de treinamento, o que
levanta preocupações éticas sobre a imparcialidade e a equidade. Outro desa o é o
enorme custo computacional associado ao treinamento e à execução desses
modelos, o que pode limitar seu acesso e uso por organizações menores ou
indivíduos.

1.3 - Prompts: a chave para um bom resultado de um LLM

Prompts são instruções ou entradas fornecidas aos Grandes Modelos de

Linguagem (LLMs) para orientar a geração de texto. Quando um usuário interage
com um LLM, ele fornece um prompt, que pode ser uma frase, pergunta ou
comando. Esses prompts são essenciais porque direcionam o modelo a produzir
uma resposta alinhada com o que o usuário deseja.

LANGFLOW 14
fl
fi
fi
fi
fi
fi
fi
ff
 A e cácia de um prompt depende muito de sua clareza e especi cidade.
Prompts bem formulados ajudam o LLM a entender melhor o contexto e a intenção
do usuário, resultando em respostas mais precisas e úteis. Quando um prompt é
claro, o modelo consegue identi car exatamente o que precisa ser abordado,
minimizando mal-entendidos e respostas irrelevantes.

Para ilustrar, considere dois exemplos de prompts sobre o livro "O Auto da
Compadecida". Um prompt especí co como "Escreva um resumo do capítulo três do
livro 'O Auto da Compadecida'" é detalhado e direciona o LLM a focar em uma parte
especí ca do livro, resultando em uma resposta mais precisa. Por outro lado, um
prompt vago como "Fale sobre 'O Auto da Compadecida'" é mais amplo e pode levar
a uma resposta genérica ou incompleta, já que não oferece um foco claro para o
modelo.

Prompts claros e bem-estruturados permitem que o modelo compreenda

melhor o que se espera dele. Isso minimiza ambiguidades e aumenta a relevância
das respostas. Ao usar prompts detalhados, os usuários podem extrair o máximo
das capacidades dos LLMs, obtendo informações especí cas e úteis. Assim, a
habilidade de formular bons prompts é crucial para aproveitar todo o potencial dos
LLMs em diversas aplicações, desde a escrita criativa até a análise de dados.

1.4 - Como criar um bom prompt?

1. De na o objetivo: O que você deseja que o LLM faça? Deseja um

resumo, uma explicação detalhada, uma comparação, ou talvez uma
geração de conteúdo criativo? Ter um objetivo claro ajuda a orientar a
formulação do prompt e a garantir que a resposta do LLM esteja alinhada
com suas expectativas.

2. Especi que o Contexto: Para que o LLM possa fornecer uma resposta
relevante, é crucial fornecer um contexto adequado. Isso inclui
informações adicionais que podem ajudar o modelo a entender melhor o
que você está pedindo. Quanto mais contexto você fornecer, mais precisa
será a resposta.

LANGFLOW 15
fi
fi
fi
fi
fi
fi
fi
fi
 3. Estruture o Prompt de Forma Lógica: A estrutura do prompt deve ser
lógica e clara. Use frases bem formuladas e organize a informação de
maneira que faça sentido.

4. Use Exemplos Concretos: Incorporar exemplos concretos no prompt

pode ser extremamente útil. Exemplos ajudam o modelo a entender
exatamente o que você está procurando.

5. Evite Ambiguidades: Evite termos vagos ou ambíguos que possam ser

interpretados de várias maneiras. Quanto mais especí co e direto for o
seu prompt, mais fácil será para o LLM entender e responder
adequadamente.

6. Teste e Ajuste: Finalmente, é importante testar os prompts e ajustar

conforme necessário

Exemplo 1: Prompt para planejamento de aula

Prompt Inicial: “Planeje uma aula de português”

Resposta do LLM:

Aula de Português: Estrutura e Funcionamento

Tema: Figuras de Linguagem

Objetivo:
- Compreender e identificar diferentes figuras de linguagem.
- Aplicar as figuras de linguagem em produções textuais.

Duração: 50 minutos

Tópicos da Aula:

- Introdução e Definição
- Apresentação do tema e importância das figuras de linguagem
na comunicação.
- Explicação das principais figuras de linguagem (metáfora,
metonímia, antítese, hipérbole, personificação) com exemplos.

Exemplificação e Discussão:

- Análise de textos curtos contendo figuras de linguagem em

grupos.
- Discussão em classe sobre as identificações feitas pelos
grupos e correção coletiva.

Atividade Prática e Conclusão:

- Criação de frases pelos alunos utilizando diferentes figuras

de linguagem.

LANGFLOW 16
fi
 - Leitura e compartilhamento das frases, seguidos de uma
revisão dos pontos principais.
- Designação de uma tarefa de casa para reforçar o conteúdo
aprendido.

Percebeu o problema? Não há um contexto ou seja, o modelo escolheu um

tema aleatório da disciplina e pode não ser o que o usuário estava procurando.
Vamos melhorar esse prompt dando uma personalidade e um objetivo bem claro do
tema que a aula deve abordar e solicitar uma metodologia especí ca para essa aula:

Prompt Melhorado: “Quero que haja com um professor especialista

em Língua Portuguesa. Planeje uma aula de português para alunos
do ensino médio, focada em Tipos de Verbo, utilizando metodologia
interativa de ensino para engajar estudantes adolescentes.”

Resposta do LLM:

Aula de Português: Tipos de Verbo

Nível: Ensino Médio

Tema: Tipos de Verbo (Regulares, Irregulares, Transitivos,

Intransitivos, Auxiliares)

Objetivo:

- Identificar e classificar diferentes tipos de verbos.

- Aplicar o conhecimento dos tipos de verbo em construções
frasais e análises textuais.

Duração: 50 minutos

Recursos:

- Quadro branco e marcadores

- Projetor e slides
- Textos e exemplos impressos
- Folhas de atividades
- Aplicativos de resposta em tempo real (ex.: Kahoot, Mentimeter)
- Cartões de verbos para atividade prática

Plano de Aula

1. Abertura e Introdução (10 minutos)

Saudação e Chamada: Cumprimentar os alunos e realizar a chamada.

Quebra-gelo: Uma breve atividade de aquecimento onde os alunos

escrevem rapidamente exemplos de verbos que conhecem em post-its
e colam no quadro.

LANGFLOW 17
fi
 Apresentação do Tema: Introduzir o objetivo da aula e a
importância de compreender os tipos de verbos para a construção
de frases corretas e expressivas.

2. Apresentação Teórica com Interatividade (15 minutos)

- Definição e Exemplos: Utilizar slides para explicar os

diferentes tipos de verbos (Regulares, Irregulares, Transitivos,
Intransitivos, Auxiliares).
- Verbos Regulares e Irregulares: Explicar a conjugação e dar
exemplos.
- Verbos Transitivos e Intransitivos: Destacar a necessidade de
complemento.
- Verbos Auxiliares: Explicar seu papel na formação de tempos
compostos.

Interatividade:

Kahoot/ Mentimeter: Realizar um quiz ao vivo onde os alunos

respondem a perguntas sobre os tipos de verbos usando seus
smartphones, incentivando a participação ativa e a competição
saudável.

3. Atividade em Grupo (15 minutos)

- Divisão em Grupos: Dividir os alunos em pequenos grupos e

distribuir cartões com verbos.
- Classificação e Criação de Frases:
+ Cada grupo deve classificar os verbos em regulares,
irregulares, transitivos, intransitivos e auxiliares.
+ Criar frases usando os verbos classificados e depois
apresentar para a turma.

- Feedback e Discussão: Os grupos apresentam suas classificações

e frases, e o professor fornece feedback, corrigindo e
esclarecendo dúvidas.

4. Conclusão e Revisão (5 minutos)

- Revisão dos Pontos Principais: Recapitular os tipos de verbos e

sua importância na construção de frases.
- Reflexão Final: Perguntar aos alunos como o conhecimento dos
tipos de verbos pode ajudar na escrita e na fala.

Tarefa de Casa: Pedir que os alunos escrevam um pequeno texto

narrativo ou descritivo, identificando e classificando os verbos
utilizados.

Avaliação

- Participação em Classe: Avaliar a participação ativa dos alunos

durante a aula e nas atividades interativas.
- Atividade em Grupo: Avaliar a classificação correta dos verbos
e a construção das frases.
- Tarefa de Casa: Corrigir e fornecer feedback sobre o uso dos
verbos no texto escrito.

LANGFLOW 18
 Exemplo 2: Criando uma persona para um assistente virtual

Prompt: “Agora você é um assistente virtual especialista em

responder questionamentos dos alunos de ensino médio sobre
álgebra linear.”

Exemplo 3: Prompt para criação de um e-mail baseado em um exemplo.

Extraído de Macedo (2024).

Prompt: “Escreva um e-mail formal para um cliente sobre o atraso

distribuição de insumos. Utilize o e-mail delimitado em <exemplo>
como referência para o tom e a estrutura.

<exemplo>

Prezado Sr. Silva,

Gostaríamos de informá-lo sobre um atraso inesperado na entrega
do seu projeto. Devido a imprevistos técnicos, não conseguiremos
concluir o trabalho dentro do prazo inicialmente estipulado.
Estamos trabalhando arduamente para resolver estas quest.es e
estimamos que a entrega será feita até o final da próxima semana.
Pedimos desculpas pelo inconveniente e agradecemos a sua
compreensão.

Atenciosamente,

João Pereira
Gerente de Projetos

</exemplo>

Agora, escreva o e-mail”

1.5 - API´s e Frameworks

Com os modelos de Grandes Modelos de Linguagem (LLM) se tornando cada

vez mais complexos e poderosos, treinar seu próprio modelo em um computador
pessoal está se tornando cada vez mais difícil. A solução mais prática é usar
servidores na nuvem, onde os recursos podem ser ajustados conforme a necessidade
do modelo.

LANGFLOW 19
 Uma API (Interface de Programação de Aplicações) é um conjunto de regras e
protocolos que permite a comunicação entre diferentes softwares. Ela de ne os
métodos e dados que os desenvolvedores podem usar para interagir com
componentes de software, como serviços web, sistemas operacionais e bibliotecas
de software. As APIs facilitam a troca de informações e a utilização de
funcionalidades entre diferentes programas, o que é essencial para integrar um
modelo LLM.

Modelos como Google Gemini, GPT e Claude são oferecidos por meio de
APIs. Para utilizar esses modelos em suas aplicações, basta criar uma chave de API,
assinar o serviço adequado e seguir a política de preços de cada empresa. Com essa
chave, você pode fazer requisições enviando prompts aos modelos e receber suas
respostas, tornando o uso dessas tecnologias acessível e e ciente.

Os Frameworks são coleções de códigos e componentes de software

disponibilizados para facilitar a programação e a integração de aplicações. Um dos
frameworks mais conhecidos para trabalhar com modelos LLM é o LangChain
(langchain.com). Ele foi projetado para construir "encadeamentos" de aplicações e
modelos de linguagem, ampliando o potencial de suas aplicações.

Embora o LangChain ofereça muitas facilidades, integrá-lo a sua aplicação

exige um conhecimento robusto de programação em Python. Isso pode limitar
muitas pessoas que desejam incluir IA em seus projetos. Para superar essa limitação
e acelerar o desenvolvimento, existem projetos que buscam minimizar a necessidade
de escrever códigos, ou até mesmo eliminar essa necessidade, tornando a integração
de IA mais acessível a todos.

1.6 - Low Code VS No Code

As abordagens Low Code e No Code estão transformando a maneira como o

software é desenvolvido, permitindo que pessoas com pouca ou nenhuma
experiência em programação criem aplicações funcionais e complexas. Essas
abordagens têm como objetivo democratizar o desenvolvimento de software,
tornando-o acessível a uma gama mais ampla de usuários, desde desenvolvedores
experientes até pro ssionais de negócios sem conhecimentos técnicos.

LANGFLOW 20
fi
fi
fi
 Low Code é uma abordagem de desenvolvimento de software que minimiza
a quantidade de código manual necessário para construir uma aplicação. Em vez de
escrever linhas extensas de código, os desenvolvedores usam interfaces grá cas e
ferramentas de arrastar e soltar para criar aplicações. Plataformas Low Code

fornecem componentes pré-construídos e modelos que podem ser con gurados e

personalizados para atender às necessidades especí cas do projeto.

No Code vai um passo além do Low Code, permitindo que usuários criem
aplicações sem escrever nenhuma linha de código. Essas plataformas são projetadas
para ser ainda mais intuitivas, visando usuários que não têm experiência em
desenvolvimento de software. A construção é feita exclusivamente através de
interfaces visuais e con gurações, tornando a tecnologia acessível a um público
ainda maior.

LANGFLOW 21
fi
fi
fi
fi
 Capítulo 2

IA sem Programar? Sim, é verdade!

Nos últimos anos, o desenvolvimento de sistemas de IA sem escrever linhas

de código de programação tem ganhado impulso graças à ascensão das plataformas
No Code. A principal característica dessas plataformas é a interface visual de
arrastar e soltar, onde os usuários podem selecionar e con gurar componentes pré-
de nidos para construir seus sistemas de IA. Esta abordagem reduz drasticamente a
complexidade associada ao desenvolvimento tradicional de IA, que geralmente exige
um conhecimento profundo de linguagens de programação, algoritmos de
aprendizado de máquina e infraestrutura computacional.

Plataformas No Code como Google AutoML, Microsoft Azure Machine

Learning Studio, e H2O.ai Driverless AI são exemplos notáveis que democratizam o
acesso à tecnologia de IA. Elas oferecem uma ampla gama de funcionalidades, desde
a importação e limpeza de dados, até a seleção de algoritmos, treinamento de
modelos e implementação. Por exemplo, um usuário pode carregar um conjunto de
dados, selecionar um tipo de modelo (como uma rede neural ou árvore de decisão),
ajustar alguns parâmetros através de menus e botões, e, em seguida, treinar o
modelo com um simples clique.

Além disso, essas plataformas frequentemente incluem ferramentas de

visualização que permitem aos usuários interpretar os resultados e entender melhor
o desempenho do modelo. Isso não apenas acelera o processo de desenvolvimento,
mas também torna a IA acessível a um público mais amplo, incluindo pro ssionais
de negócios e analistas de dados que anteriormente não tinham a capacidade técnica
para desenvolver sistemas de IA.

É importante ressaltar que ao desenvolver um sistema com essas ferramentas

a solução não terá tanta exibilidade de mudanças se o framework não permitir que
o usuário crie ou customize totalmente seus próprios componentes.

LANGFLOW 22
fi
fl
fi
fi
 2.1 - Seja bem-vindo ao Lang ow!

Em 2022 na cidade de Uberlândia-MG, a Logspace foi criada por Rodrigo

Nader e Gabriel Almeida, dois cientistas de dados com experiência prévia nas
startups californianas Bitvore e WooHoo. Em março de 2023, lançaram a ferramenta
Lang ow, desenvolvida com capital próprio.

O Lang ow é uma solução baseada em Python, uma linguagem de

programação amplamente utilizada em ciência de dados e machine learning. Desde
seu lançamento, o Lang ow atraiu mais de 16 mil desenvolvedores na plataforma
GitHub, especialmente dos Estados Unidos, Alemanha e Índia.

Em abril de 2024 a empresa norte-americana DataStax especializada em

soluções de banco de dados, anunciou a aquisição da Logspace e anunciou planos de
investimento.

LANGFLOW 23
fl
fl
fl
fl
 Lang ow é uma interface web para o LangChain (www.langchain.com),
projetada com react- ow e oferece uma maneira simples de experimentar e
prototipar uxos. O LangChain, foi criado por Harrison Chase e é um framework
extremamente popular para desenvolver aplicações com base em grandes modelos
de linguagem (LLMs).

Para simpli car processos complexos de programação, o LangFlow permite

que usuários, independentemente de sua experiência em desenvolvimento de
software, possam construir aplicações robustas de IA utilizando uma interface de
arrastar e soltar.

2.2 - Iniciando com Lang ow

Desde da união com a DataStax, é possível utilizarmos o Lang ow duas

maneiras:

• Através do serviço em nuvem da DataStax, de forma gratuita, sem

necessidade de instalação e com uma integração com o banco de dados AstraDB
(https://lang ow.datastax.com)

• Através da uma instalação local

LANGFLOW 24
fl
fl
fl
fi
fl
fl
fl
 Obs: A versões do Lang ow utilizadas na produção desse livro fora a 1.0.10 e
1.0.14. É necessária a versão Python 3.10 ou superior instalada em seu computador

python -m pip install langflow -U

Caso tenha algum problema na instalação você pode executar o seguinde

comando para obter ajuda na instalação

python -m langflow —-help

ou ainda, acessar a documentação o cial que apresenta como solucionar os

problemas mais comuns encontrados durante instalação: https://docs.lang ow.org/
getting-started-common-installation-issues

1 - Executando o Lang ow na linha de comando:

python -m langflow run

2 - Para con rmar que a versão local do Lang ow iniciou você pode acessar a
URL http://127.0.0.1:7860 de seu navegador.

Uma excelente opção de instalação é utilizar a imagem em Docker

disponível no repositório o cial do Lang ow, seguindo os
procedimentos descritos em https://github.com/lang ow-ai/lang ow/
tree/main/docker_example

Repositório o cial no gitbub: https://github.com/lang ow-ai/lang ow

LANGFLOW 25
fi
fi
fl
fl
fi
fi
fl
fl
fl
fl
fl
fl
fl
2.3 - Tour pelo Lang ow

A primeira tela exibida na inicialização do Lang ow é onde podemos

visualizar os projetos criados e acessar o botão “New Project” no canto superior
direito para criamos novos projetos ( uxos).

Ao clicar em um projeto criado ou iniciar um projeto novo, a interface

principal é exibida. A interface do Lang ow foi dividida aqui em várias seções, cada
uma com funções especí cas que facilitam o processo de desenvolvimento.

LANGFLOW 26
fi
fl
fl
fl
fl
 1 - Área de Trabalho Principal (Fluxos)

Drag and Drop: A área central da interface onde os usuários podem arrastar e soltar
componentes para construir seus uxos de trabalho. Cada componente representa
uma etapa no processo de desenvolvimento, como a importação de dados, pré-
processamento, treinamento de modelos e avaliação de resultados.

Conexões Visuais: Linhas e setas que conectam os componentes, indicando o uxo

de dados e a sequência de operações. Isso ajuda a visualizar claramente como as
diferentes partes do sistema interagem entre si.

2 - Biblioteca de Componentes

Componentes Pré-Construídos: Um painel lateral contendo uma vasta gama de

componentes pré-construídos que podem ser usados no desenvolvimento de
aplicações de IA. Esses componentes incluem módulos para manipulação de dados,
algoritmos de aprendizado de máquina, ferramentas de visualização e muito mais.

Busca e Filtros: Ferramentas de busca e ltros que facilitam encontrar rapidamente

os componentes necessários para o seu projeto.

3 - Painel de Propriedades:

Con gurações de Componentes: Quando um componente é selecionado na área de

trabalho, o painel de propriedades exibe todas as suas con gurações e parâmetros.
Isso permite aos usuários personalizar cada etapa do uxo de trabalho conforme
suas necessidades especí cas.

Ajustes Dinâmicos: Modi cações em tempo real nos parâmetros, com feedback
imediato sobre como essas mudanças afetam o uxo de trabalho.

Execução de Fluxos: Botões e controles para iniciar, pausar e parar a execução dos
uxos de trabalho. Isso permite testar e ajustar rapidamente os sistemas
desenvolvidos.

LANGFLOW 27
fl
fi
fi
fi
fl
fi
fl
fl
fi
fl
4 - Teste e Distribuição:

Playground: Uma interface onde pode realizar interações com o uxo e testar seus
resultados.

API: Obtenção de códigos para integração de seu projeto com suas aplicações, sites,
etc.

Os projetos exemplares deste livro são cuidadosamente selecionados e apresentados

de maneira didática. Muitos são adaptados da documentação o cial para ilustrar a
construção de projetos com Lang ow e seus componentes. Embora existam dezenas
de outros componentes no framework que não são mencionados aqui por questões
pedagógicas, recomendamos consultar a documentação o cial de cada componente à
medida que você avança em seu aprendizado.

LANGFLOW 28
fl
fi
fi
fl
Capítulo 3

Vamos criar um Chatbot com LLM

usando Lang ow? Pegue seu
capacete!

Para começarmos, vamos criar um primeiro sistema: Um chatbot usando um

modelo GPT. Antes de entrarmos diretamente no Lang ow, precisamos de uma
chave de API do modelo LLM que vamos utilizar:

3.1 - Gerando chave de API da OpenAI

Para interagir com modelos da família GPT, da OpenAI, é necessário criarmos

uma chave de API. Para obter sua chave de API da OpenAI, você precisa se inscrever
na plataforma OpenAI (https://platform.openai.com/docs/overview) , acessar sua
conta e gerar uma chave de API através do painel de con gurações (settings).

LANGFLOW 29
fl
fi
fl
 3.2 - Começando o Chatbot

Agora que nós já temos nossa chave de API, podemos criar o projeto no
Lang ow:

1 - Com o Lang ow em execução, acesse localhost:7860 (ou o projeto

DataStax Lang ow on line) e clique em “New Project”

2 - Um janela será exibida com as opções de templates iniciais, escolha a

opção “Basic Prompt (Hello, World)”

LANGFLOW 30
fl
fl
fl
LANGFLOW 31
 3 - Um uxo inicial será criado utilizando 4 componentes conectados por
uma linhas:

Analisando melhor esse uxo, podemos notar características interessantes,

que serão essenciais na criação de nossos próprios projetos. O uxo apresenta 4
componentes (que são essas caixas) e 3 linhas ligando as caixas.

Cada compontente tem um ou mais pontos de conexão de entrada (esquerda)

e saída (direita) onde as linhas são conectadas.

3.3 - Componente Chat Input

O primeiro componente (caixa) é

chamado de “Chat Input” e é utilizado para
iniciar o uxo, ou seja capturar a primeira
mensagem do usuário que será enviada ao
modelo LLM. Do lado esquerdo do componente
tem um ponto de entrada e do lado direito, na
frente da palavra “message” um ponto de saída,
que neste exemplo é conectado ao próximo
componente do uxo.

3.4 - Componente Prompt

O segundo componente é chamado

“Prompt” e é aqui que vamos introduzir o
template do prompt para o modelo LLM (já
abordamos a importância dele para o modelo).
Note que a saída do componente “Chat Input”
está conectado a entrada do Prompt na palavra
“user_input”; Essa palavra será uma variável
dentro do prompt e pode ser personalizada. Na
saída do componente (direita) encontramos a
palavra “Prompt Message”, que será o prompt
comp l eto a ser for necido ao p r óximo
componente. Ao clicarmos no ícone ao lado do

LANGFLOW 32
fl
fl
fl
fl
fl
campo “Template" temos acesso a uma janela de personalização do nosso prompt
inicial. Que está personalizado como “Answer the user as if you were a pirate” (Responda
ao usuário como se fosse um pirata).

3.5 - Componente OpenAI

O terceiro componente é chamado

“OpenAI” e como deve ter imaginado é a
interação com o modelo LLM. Nesse caso, algum
disponibilizado pela OpenAI que podemos
escolher. Esse componente recebe como entrada
o prompt formatado na variável “input” e envia a
resposta vinda do modelo GPT para o próximo
componente através da variável de saída “Text”.
Nesse componente precisamos inserir nossas
credenciais de acesso (OpenAI API Key) e
escolher o modelo desejado na lista fornecida
pela plataforma em “Model Name". O parâmetro
"temperature" na API da OpenAI controla o nível
de aleatoriedade nas respostas do modelo, com
valores mais baixos resultando em respostas mais determinísticas e valores mais
altos gerando respostas mais variadas.

LANGFLOW 33
3.6 - Componente Chat Output

O último componente do uxo é chamado

“Chat Output”, é por meio desse componente que
poderemos ver a resposta do modelo através da
janela “Playground” . Note que ele recebe como
entrada na variável “Text” a conexão da saída
“Text” do componente LLM OpenAI.

No menu de propriedades de cada componente você escontrará a

opção “Freeze”, que literalment, “congela” a saída do componente até
que você desative essa oção. Se torna um ótimo recurso ter a saída
preservada pois não há execução da chamada de API no caso do
models LLM impedindo gastos desnecessários

3.7 - Playground

Depois de tudo conectado e con gurado, podemos testar o uxo através da

janela “Playground” na parte inferior da janela do Lang ow.

LANGFLOW 34
fl
fi
fl
fl
 Aí está, nosso primeiro chatbot utilizando o Lang ow! Você deve estar se
perguntando: Só isso? E a resposta é: Isso mesmo, só isso. Criamos nosso primeiro
chatbot interagindo com o OpenAI e não utilizamos nenhuma linha de código.

3.8 - Gerando Chave de API do Google Generative AI

(Gemini)

Mas e se eu não quiser usar o OpenAI? Simples, basta substituir o

componente! Vamos fazer isso mudando o LLM para o Google Gemini?

Se você ainda não tem sua chave de API do Gemini, pode criá-la facilmente
seguindo os passos abaixo:

1 - Acesse o Google AI Studio (aistudio.google.com) e clique sobre o botão

“Get API Key”

2 - Clique sobre o botão “Criar chave de API”. Você pode criar um novo
projeto ou apenas adicionar uma nova chave a um projeto já existente.

3 - Escolha o projeto e clique sobre “Criar uma chave de API em um projeto

atual”. Uma chave será apresentada com um botão “Copiar”. Lembre-se que essa
chave não deve ser compartilhada.

LANGFLOW 35
fl
 3.9 - Componente Google Generative AI (Gemini)

Agora que já temos uma chave do Gemini, vamos substituir o componente no

uxo do chatbot que criamos no Lang ow:

1 - Clique na barra de componentes (esquerda) escolha a categoria “Models"

e expanda as opções para encontrar o compontente “Google Generative AI” e
arraste-o para a área de desenho do uxo.

2 - Clique sobre a linha que conecta o uxo de saída do Prompt e delete.

Clique novamente sobre o ponto de saída do Prompt e arraste a linha para conectá-
lo ao ponto “Input" do componente Google Generative AI. Apaque a linha de saída
do componente OpenAI e conect a linha de saída (Text) do Google Generative AI.

Agora só precisamos con gurar o novo componente, pois o Google

Generative AI (Gemini) precisa de parâmetros diferentes do OpenAI. Em “Max
Output Tokens” podemos de nir um tamanho máximo, ou seja, a quantidade
máxima de palavras da resposta gerada pelo modelo. Os parâmetros “Model”,

LANGFLOW 36
fl
fi
fi
fl
fl
fl
"Google API Key” e “Temperature" são semelhantes ao componente usado
anteriormente. Coloque sua nova chave e escolha o modelo desejado.

Abra novamente a janela de Playground e interaja com o novo modelo. Você

pode clica no ícone superior direto da janela para “limpar" toda a interação feita
anteriormente.

Notou algo diferente? O Gemini respondeu em inglês (no meu caso) e

acrescentou ícones ao m da frase. Ok, mas como posso fazer com que ele responda

LANGFLOW 37
fi
em português? Tudo isso pode ser personalizado através do componente de Prompt
e, como deve se lembrar, está escrito em inglês no projeto padrão do Lang ow.
Então, basta que acessemos o componente para dar mais alguns direcionamentos ao
Gemini.

Feche a janela de Playground e clique sobre o componente de Prompt e clique

sobre ícone ao lado do campo “template”. Altere o prompt de acordo com a imagem
abaixo, deixando-o em português e orientando o modelo a responder sempre nesse
idioma. Clique em “Check & Save”.

Agora volte à janela de Playground, limpe a interação anterior e refaça o teste:

Et voiala! Seu primeiro chatbot interagindo com um LLM. Na verdade com

dois. Esse capítulo mostrou a simplicidade de se interagir com um modelo LLM,

LANGFLOW 38
fl
 seja ele OpenAI ou Google Gemini, apenas substituindo um componente. Aliás o
componente OpenAI nesse uxo cou sem utilidade e pode até ser deletado.

Para salvar seu projeto, você pode clicar no canto superior esquerdo da tela
do Lang ow (ao lado do ícone) para acessar a opção “Settings" e renomear o
projeto.

O mais legal é que podemos ainda fazer com que um uxo interaja com os
dois. E se um modelo LLM pudesse criar um texto para que o outro revise? Como
deve saber esses modelos de LLM tem custos e capacidades variadas, então eu
poderia deixar as tarefas mais simples para modelos mais baratos e mais simples e
as tarefas mais complexas para modelos mais caros, deixando meu projeto muito
mais interessante. Na verdade, vamos fazer isso nos capítulos seguintes. Let it Rip!

LANGFLOW 39
fl
fl
fi
fl
 Capítulo 4

Criando um Redator para seu Blog

Nesse projeto vamos utilizar alguns componentes que já conhecemos e

outros novos. Sempre que formos utilizar um componente novo teremos um item
explicativo sobre ele. O propósito desse uxo será utilizarmos um modelo LLM para
atuar como um redator de textos para nosso blog. Lembre-se que esse exemplo pode
ser adaptado para outras funcionalidades como escrever posts para sua rede social
pois o princípio é o mesmo.

Inicie um novo projeto no Lang ow e escolha a opção “Blog Writer”. Um

uxo pré-con gurado será exibido para que possamos fazer os ajustes necessários.

Esse novo uxo é bem parecido com o projeto que zemos anteriormente,
mas você pode observar que não tem uma entrada de interação com o usuário como
acontece em um chat, então as entradas do uxo cam por conta de “URL” e
“Instructions”.

Note que cada componente possui um ícone do tipo “play” no canto superior
direito. Isso permite que o componente pode ser executado individualmente. Você
precisa levar em conta sempre as entradas e saídas de cada um deles.

Quando repousamos o ponteiro

do mouse sobre as entradas e
saídas de um componente
podemos ober uma janela
uturante que apresenta quais
os tipos de entrada/saída são
esperados pelo componente.
Isso é extremamente útil para
conectar os componentes.

LANGFLOW 40
fl
fl
fi
fl
fl
fl
fl
fi
fi
LANGFLOW 41
4.1 - Componente URL

O componente URL é extremamente util quando

queremos enviar alguma referência de site na internet para
formatação do prompt que será enviado ao modelo.
Podemos utilizar apenas uma URL's ou adicionar mais
clicando no ícone “+”. Nesse projeto eu alterei o valor de
URL para "https://ai.google/why-ai/" (Blog do Google AI).
O formato de saída desse componente é um objeto do tipo
“Data”. E é exatamente por esse motivo que não podemos
conectá-lo diretamente ao componente Prompt, precisamos
convertê-lo antes.

4.2 - Componente Parse Data

Esse componente é responsável por realizar

“Parse” (Conversão) de dados. Ele recebe como entrada
um objeto do tipo “Data” e como saída teremos um tipo
“Text”. Para realizar esse parse, precisamos mapear o
objeto de entrada e direcionar a saída, nesse exemplo o
objeto de entrada vindo de URL está sendo direcionado
para a variável com o nome “text" que aparece no campo
template entre chaves {text}.

4.3 - Componente Text Input

O componente que aparece no uxo criado pelo Lang ow como

“Instructions” na verdade é um componente “Text Input” e ele é utilizado para
incluir textos a serem repassados em uma variável para o próximo componente.

LANGFLOW 42
fl
fl
 Nesse projeto, utilizamos
esse campo para colocar
textos que servirão como
referência de estilo de
texto para ajuste do
Prompt. Para renomear
um componente (como
foi feito com esse) basta
dar um duplo clique
sobre o nome.

4.4 - Con gurando o Prompt

Agora vamos nos concentrar no componente Prompt (já visto anteriormente).

Ele está recebendo os valores de entrada de Parse Data (conteúdo de URL) e o
conteúdo de Text Input (Instructions).

Nota: Se as variáveis “instructs” e “references” que são os pontos de entrada

do Prompt não existissem, ou se precisar criar mais alguma, basta abrir a janela de
personalização do Prompt e digitar os nomes das variáveis entre chaves
{minha_variavel_entrada} e o ponto de entrada será criado automaticamente.

Personalize o template do componente Prompt como zemos na gura

abaixo:

LANGFLOW 43
fi
fi
fi
 4.5 - Testando 1, 2, 3

Não se esqueça de colocar sua chave de API e escolha do modelo no

componente OpenAI e vamos executar esse uxo clicando em Playground:

Aqui está, o post para o seu blog pronto para ser postado, com o tema que
escolhemos e com o estilo literário que de nimos. Ah, se quiser em outro idioma
basta de nir isso no Prompt.

Legal, mas e se eu quiser criar um post para minha rede social como X
(antigo Twitter) ou Instagram? O funcionamento é o mesmo, apenas lembre-se de
delimitar o tamanho da resposta no seu Prompt pois nessas redes o tamanho do
texto é limitado.

LANGFLOW 44
fi
fi
fl
Capítulo 5

IA com os Meus Próprios Dados

Neste capítulo, exploraremos como utilizar a Inteligência Arti cial para

trabalhar com seus próprios dados, mergulhando em técnicas avançadas que
permitem criar sistemas personalizados e altamente e cientes. Vamos começar com
uma introdução ao conceito de Geração Aumentada por Recuperação (Retrieval
Augmented Generation - RAG), que combina a recuperação de informações com a
geração de texto para melhorar a precisão e relevância das respostas. Em seguida,
discutiremos a importância dos embeddings, que são representações vetoriais de
dados que capturam signi cados e relações contextuais. Por m, apresentaremos as
Vector Stores, que são bancos de dados otimizados para armazenar e consultar esses
embeddings, permitindo buscas rápidas e precisas em grandes volumes de dados.
Este capítulo fornecerá as bases necessárias para que você possa implementar
soluções de IA que aproveitam ao máximo os seus dados especí cos, criando
aplicações personalizadas e inteligentes.

5.1 - Geração Aumentada por Recuperação (RAG)

A Geração Aumentada por Recuperação (RAG) é uma técnica avançada em

inteligência arti cial que combina a recuperação de informações com a geração de
texto. Essa abordagem permite que os modelos de linguagem não apenas gerem
respostas baseadas em conhecimento preexistente (seus treinamentos), mas
também busquem informações relevantes em fontes de dados especí cas para
fornecer respostas mais precisas e contextualmente mais relevantes.

O processo de RAG geralmente envolve duas etapas: Recuperar uma

Informação, em um banco de dados ou conjunto de documentos e Geração de
Texto com base em uma síntese dos textos recuperados respondendo ao prompt do
usuário.

LANGFLOW 45
fi
fi
fi
fi
fi
fi
fi
 Ao combinar um modelo de linguagem LLM com nossos próprios dados o
RAG permite o desenvolvimento de IA’s altamente personalizadas, o que pode
reduzir drasticamente a possibilidade de respostas erradas (alucinações) do modelo
e atender às necessidades especí cas do usuário.

5.2 - Embeddings

Uma técnica muito utilizada em Processamento de Linguagem Natural (PLN)

e em muitas outras áreas da IA é o processe de Embedding que simpli cando, são
representações vetoriais de dados como palavras ou frases. Essa representação
vetoria é feita com base em algoritmos próprios e em vez de tratarmos de
semelhanças de palavras para entendimento do contexto, utilizamos a distância
vetorial dessas representações no espaço multidimensional.

Imagine que as palavras male (masculino), man (homem), queen (rainha),

woman (mulher) foram transformadas em vetor e estão dispostas em um espaço
multidimensional como aparece na gura abaixo:

A distância entre os pontos king e queen é a mesma entre man e woman,

então é possivel dedizir que há uma relação de similaridade entre esses pontos.
Quando realizamos um Embedding, todos as palavras e frases são “vetorizadas" e
possuirão uma representação nesse plano, possibilitando a busca de um ponto e
seus similares. É assim que os modelos conseguem prever a próxima palavra em
uma frase e é assim que eles conseguem escrever textos que façam sentido.

LANGFLOW 46
fi
fi
fi
 A gura acima, obtida de (https://qdrant.tech/articles/what-are-
embeddings/) resume bem como funciona esse processo de Embedding. Os dados
são submetidos a modelos de Embedding que cria suas representações vetoriais
determinando sua posição, permitindo assim a
busca por similaridade no espaço multidimensional.

No Lang ow, temos componentes que

podem adicionar esses Modelos de Embeddings de
diversos fornecedores como OpenAI, Google,
Amazon, Mistral, etc. ao nosso projeto.

Para utilizar um desses componentes, tudo

que precisamos fazer é arrastar seu componente
escolhido para o uxo e fornecer as con gurações
adequadas. A maioria precisa apenas de sua chave
de API e qual modelo de Embedding deseja utilizar.

Como nos demais componentes eles tem

suas entradas e saídas, então, a entrada sempre será
o texto a ser convertido em Vetor de Embedding e a
saída será o vetor.

Um cuidado que precisamos ter é usarmos o

mesmo modelo para recuperar o dado um vetor de
embedding que senha sido armazenado anteriormente.

LANGFLOW 47
fi
fl
fl
fi
 5.3 - Vector Store

Um Vector Store é um tipo de banco de

dados especializado projetado para armazenar e
consultar vetores de alta dimensão, que são
representações matemáticas de dados, como
embeddings. Esses vetores são usados para
capturar e preservar a semântica e o contexto de
informações complexas, como palavras, frases,
imagens ou qualquer outro tipo de dados que
possam ser representados numericamente em um
espaço vetorial.

Um vector store serve como uma

infraestrutura crucial para armazenar, indexar e
buscar embeddings de maneira e ciente. Aqui
estão algumas de suas principais funções e
aplicações:

Armazenamento de Embeddings: Permite armazenar grandes volumes de

embeddings gerados por modelos de aprendizado profundo. Esses embeddings
podem representar palavras, documentos, imagens ou outros tipos de dados
complexos.

Busca Semântica: Facilita a busca por similaridade semântica em grandes

conjuntos de dados. Em vez de realizar buscas textuais tradicionais, um vector store
permite encontrar dados que são semanticamente semelhantes ao vetor de consulta,
resultando em respostas mais precisas e contextualmente relevantes.

Recuperação e Geração de Informação: Em sistemas RAG, os vector stores são

usados para recuperar informações relevantes a partir de grandes bases de dados,
que são então utilizadas para gerar respostas contextualizadas e precisas.

No Lan ow, vários componentes do tipo Vector Store são fornecidos

nativamente. Com destaque para o AstraDB produzido pela DataStax, agora dona
do Lang ow. Esse Vector Store é baseado no Apache Cassandra (https://

LANGFLOW 48
fl
fl
fi
cassandra.apache.org/_/index.html), possui plano limitado de forma gratuita mas
pode facilmente ser ajustado para maiores capacidades sem impacto em seu projeto.
Um componente do Chroma DB (https://github.com/chroma-core/chroma)
também está disponível de forma nativa assim como outros já conhecidos.

Todos tem o funcionamento bem parecido, precisará con gurar seus

parâmetros de acesso e conectá-los sua entrada à saída do componente Embedding e
sua saída pode necessitar de um componente Parse Data pois provavelmente
retornarão em objeto JSON como a maioria dos bancos NoSQL.

LANGFLOW 49
fi
Capítulo 6

Criando um ChatBot com Base

em um Arquivo Próprio

Nesse projeto vamos criar um chatbot que use um arquivo nosso para
responder as questões do usuário.

1 - Crie um novo projeto no Langlow do tipo Document QA

LANGFLOW 50
 2 - O uxo do novo projeto será apresentado para que façamos nossos
ajustes:

Como podemos observar, os componentes do uxo são os mesmos do

primeiro chatbot, exceto pelo componente “File” ligado ao “Parse Data” ligados ao
Prompt. O componente “File” permite que possamos escolher um arquivo em
vários formatos, incluindo o PDF. O componente Parse é necessário para fazer a
conversão em formato texto antes de enviarmos ao Prompt.

Para esse exemplo eu forneci um documento PDF de uma aula e personalizei

o prompt:

LANGFLOW 51
fl
fl
 Termine a con guração colocando suas credenciais no componente do
modelo LLM e faça o teste clicando na área de Playground:

Se você clicar nas propriedades avançadas do componente “File” poderá visualizar as

con gurações da variável Path, sendo descritos como
formatos válidos de arquivos de entrada: txt, md,
mdx, csv, json, yaml, xml, html, htm, pdf, docx, py,
sh, sql, js, ts e tsx.

LANGFLOW 52
fi
fi
 Caso precise carregar mais de um arquivo, utilize o componente “Directory”
que pode carregar recursivamente vários arquivos, bastando informar a pasta onde
esses arquivos estão e quais os formatos permitidos.

É importante lembrar que esses documentos estarão sendo carregados e

submetidos ao modelo TODAS as vezes em que executamos o nosso uxo. Isso
pode não ser uma abordagem interessante se esse uxo for executado com
frequência ou mesmo se houver um grande número de arquivos.

LANGFLOW 53
fl
fl
 Capítulo 7

Chatbot RAG com Dados Sobre a

Dengue

Como vimos no capítulo anterior, se tivermos um arquivo muito grande a ser

carregado ou se esse uxo precisar ser executado muitas vezes, o custo
computacional e nanceiro pode inviabilizar o seu projeto. O ideal é que essa
informação customizada persista em algum lugar onde o modelo possa recuperá-la e
responder ao usuário.

Além do fato de podermos conectar nossa aplicação de chatbot a um banco de

dados compartihado com outras aplicações.

Nesse projeto, a
título de exemplo, faremos
uso das técnicas de RAG
para criar um chatbot da
"Cartilha Dengue:
Pro ssionais da Atenção
Primária da Saúde -
Orientações para Diangóstico e Manejo Clínico”, criada pelo Ministério da Saúde em
formato PDF de 12 páginas e publicada em:

https://www.gov.br/saude/pt-br/centrais-de-conteudo/publicacoes/cartilhas/2024/
dengue-pro ssionais-da-aps-orientacoes-para-diagnostico-e-manejo-clinico/
@@download/ le

7.1 - Gravando Nosso Embedding em um Banco de Dados

LANGFLOW 54
fi
fi
fi
fi
fl
 Nesse exemplo utilizaremos como Vector Store o banco de dados AstraDB. A
primeira coisa a fazer é carregar nossos arquivos, criar nosso Embedding e
armazenar no AstraDB.

1 - Vamos criar um projeto em branco no Lang ow

2 - Arraste os seguintes compentes: File, Language Recursive Text Splitter,

OpenAI Embeddings e Astra DB.

3 - Vamos carregar o componente File com nosso arquivo PDF da Cartilha

sobre a Dengue.

4 - A saída do componente File será conectada a entrada (input) do

componente “Language Recursive Text Splitter”. Esse componente “quebra” os
textos em pequenos pedaços para que possamos gerar nossos Embeddings. Esses
pedaços são comumente chamados de “Chunks”. O parâmetro "Chunk Size” é

LANGFLOW 55
fl
 exatamente o tamanho que podemos de nir para esses pedaços, que normalmente
são de nidos como 1000 tokens (palavras). O parâmetro “Chunk Overlap”
determina o tamanho da sobreposição de palavras no início e m de cada chunk,
com o intuito de que não seja perdido o contexto que se trata o trecho do texto. O
padrão aqui é de 200. A linguagem que será utilizada no Spitter ainda pode ser
personalizada. O padrão é a linguagem Python.

5 - Clique no botão de Play do componente de Splitter para que ele execute o

uxo até aqui. Clicando na parte inferior do componente em “Data” uma janela é
aberta com a saída do componente e então poderemos ver o que os componentes já
zeram, note a separação em chunks, contendo a referência do arquivo e o texto
extraído.

LANGFLOW 56
fi
fl
fi
fi
fi
 6 - Como a saída do componente Splitter é um objeto do tipo Data,
precisamos conectá-lo a entrada do componente AstraDB, no conector “Ingest
Data”. E o componente Open AI Embeddings também será conectado ao AstraDB
no conector “Embedding or Astra Vectorize”.

7 - Agora, precisamos con gurar o componente OpenAI Embeddings com

nossa chave de API e escolher o modelo de Embedding. Vamos escolher o menor
modelo “Small” dada a simplicidade desse projeto.

8 - No componente AstraDB, precisamos fornecer nossas credenciais

“AstraDB Application Token”, API Endpoint e especi car qual a coleção de dados
“Collection Name” utilizaremos.

Se você ainda não possui a coleção de dados criada no AstraDB, basta acessar
a URL: astra.datastax.com criar seu usuário (pode usar sua conta Google ou
GitHub).

Após fazer login na plataforma, precisa clicar em "Databases" e "Create

Database”.

Escolha a opção "Servless (Vector)”, escolha um nome para o banco de dados,

uma nuvem onde será armazenado (AWS, Google Cloud ou Azure) e a Região.

Depois de criado o banco de dados, você poderá acessá-lo e ter clicar nas abas
de Overview (visão geral), Data Explorer (explorar dados) e Settings

LANGFLOW 57
fi
fi
 (Con gurações). Mas o mais importante nesse momento de integrá-lo a nosso uxo
no Lang ow são os detalhes API Endpoint e Application Tokens

Acesse a aba Data Explorer dentro de seu database e clique sobre o botão
“Create Collection”. Dê um nome a sua coleção de dados, escolha a opção “Bring my
Own” porque faremos nosso próprio Embedding no uxo do Lang ow, escolha a
opção “1536” em Dimensions e em Similarity Metric, escolha “Cosine”.

LANGFLOW 58
fi
fl
fl
fl
fl
 Vá até o quadro Application Token em Overview e clique em “Generate
Token” e copie o valor gerado e preencha o parâmetro no componente AstraDB do
Lang ow. Copie também o valor de API Endpoint e cole no componente. Preencha
também o parâmetro Collection Name com o nome que escolheu em em sua
coleção.

Execute o uxo até esse ponto clicando no ícone de play no componente

AstraDB. Se tudo estiver correto você receberá a mensagem de que o banco de
dados foi costruído.

Retornando ao DataStax você poderá acessar Data Explorer de seu database

e escolher a nova coleção e constatar que seus dados extraídos do arquivo PDF, em
pedaços (chunks) e transformados em vetores de Embeddings foram armazenados
corretamente no AstraDB.

LANGFLOW 59
fl
fl
 7.2 - Recuperando Dados em nosso Banco de Embeddings

Agora que nossos Embeddings já estão armazenados em uma coleção dentro

do AstraDB, vamos construir um uxo de chatbot que recupera as informações de lá
para interagir com o modelo LLM e com o usuário.

1 - Crie um novo uxo em branco no Lang ow

2 - Arraste os seguintes componentes para a área principal: Chat Input,

Prompt, OpenAI, OpenAI Embeddings, Parse Data, Astra DB, Chat Output

3 - Selecione o componente Prompt adicionado ao uxo e edite o “template”.

Isso vai criar duas variáveis: {context} e {question}

4 - Coloque sua chave da OpenAI API no

componente OpenAI Embeddings e conecte a saída
(embeddings) dele ao conector “Embeddings or Astra
Vectorize" do componente Astra DB.

5 - Coloque suas credenciais (Collection Name,

AstraDB Token e API Endpoint) no componente Astra
DB.

6 - Ligue o conector “Search Results” da saída do

AstraDB ao conector “Data” do componente Parse
Data. Certi que-se de que em template do componente

LANGFLOW 60
fi
fl
fl
fl
fl
Parse Data encontra-se criada a variável {text}.

7 - Ligue o conector “Message” na saída de Chat Input ao conector

“question” em Prompt; Ligue o mesmo conector “Message” ao AstraDB no
conector “Search Input”

Até o momento as ligações deve estar conforme a gura abaixo:

8 - Ligue o conector “Prompt Message” de Prompt ao conector “Input” do

componente OpenAI

9 - Forneça suas credenciais da OpenAI no campo “OpenAI API Key” do

compente OpenAI e escolha o modelo gpt-4o (mais barato atualmente)

10 - Conecte a saída “Text” do OpenAI ao conector “Text” do componente

Chat Output

LANGFLOW 61
fi
7.3 - Testando Tudo

Vamos executar nosso chatbot a área de Playground para realizar alguns

testes.

LANGFLOW 62
 Parece uma resposta genérica do modelo LLM, então, como con rmar se
nosso chatbot está realmente buscando dados de nossa Cartilha? Vamos ser um
pouco mais incisivos perguntando algo direto:

O número que o chatbot respondeu parece preciso demais pra ter sido
“inventado” não acha? Vamos ver na Cartilha do Ministério da Saúde que
fornecemos ao modelo, na página 5:

Então, realmente ele está respondendo com base nas informações que
guardamos no AstraDB. Mas observe algo interessante se perguntarmos ao modelo
algo que não tenha nada relacionado à Dengue:

LANGFLOW 63
fi
 Quando criamos um chatbot para um determinado domínio, queremos que
ele responda apenas a assuntos relacionados a aquele assunto, certo? Vamos
resolver isso ajustando nosso Prompt:

Assim, estamos direcionando o modelo a não responder nada fora do

contexto em que ele foi de nido. Vamos salvar o prompt ajustado e realizar um
novo teste:

LANGFLOW 64
fi
 Capítulo 8

Criação de Componentes no
Lang ow: Eu quero Programar!

O Lang ow foi projetado para a construção de uxos de trabalho com

agentes inteligentes e modelos de linguagem, e oferece uma vasta gama de
componentes prontos para uso. Esses componentes simpli cam o processo de
integração de várias funcionalidades e permitem que os desenvolvedores foquem
mais na lógica de negócio e menos na infraestrutura.

Entre os componentes nativos mais comuns do Lang ow estão os módulos

de entrada e saída de dados, os componentes de processamento de linguagem
natural (NLP), ferramentas de análise e módulos de integração com outras APIs e
múltiplo serviços como execução de scripts, ferramentas utilitárias, etc. Esses
componentes são projetados para serem facilmente conectados uns aos outros,
permitindo a criação de uxos de trabalho complexos com uma simplicidade
impressionante.

Uma das características mais poderosas

do Lang ow é a capacidade de criar
componentes personalizados. Essa
funcionalidade permite que os desenvolvedores
adaptem a biblioteca às suas necessidades
especí cas, criando novos módulos que podem
ser integrados aos uxos de trabalho
existentes. A criação de componentes
personalizados é crucial porque oferece a
exibilidade necessária para implementar
funcionalidades únicas que não estão cobertas
pelos componentes padrões.

LANGFLOW 65
fl
fi
fl
fl
fl
fl
fl
fl
fl
fi
 Componentes personalizados facilitam a reutilização de código. Uma vez
criado, um componente personalizado pode ser reutilizado em múltiplos projetos,
economizando tempo e esforço de desenvolvimento e pode ser compartilhado com a
comunidade. Isso é particularmente útil em ambientes corporativos, onde diferentes
equipes podem compartilhar componentes desenvolvidos internamente,
promovendo uma cultura de colaboração e e ciência.

8.1 - Nosso Próprio Componente de Transcrição de Vídeo

Para criar um componente personalizado no Lang ow, precisamos de nir a

lógica do componente e como ele vai se integrar com outros módulos. Isso
geralmente envolve a implementação de interfaces especí cas que permitem que o
novo componente receba dados de outros módulos e envie suas saídas de volta para
o uxo de trabalho principal.

Até o momento a instalação padrão do Lang ow não conta com um

componente que possa fazer a transcrição de um vídeo do Youtube para que
possamos usar como fonte de contexto. Claro que alguns modelos multimodais já
podem processar diretamente o vídeo apenas lhe
enviando a URL do vídeo, mas pode ser útil em
algum momento utilizarmos a transcrição de um
vídeo. Então, vamos criar nosso próprio
componente.

O primeiro passo é arrastarmos um

Custom Component para nossa área de
construção de uxos. Você pode encontrá-lo no
grupo “Helpers” ou buscá-lo no menu de
componentes.

Ao clicar no componente e acionar o seu

menu superior no ícone <> podemos acessar a
janela de edição de código.

LANGFLOW 66
fl
fl
fi
fl
fl
fi
fi
 Nessa janela poderemos escrever nosso próprio código Python com
instruções para o componente. Vamos substituir esse código padrão por esse:

from langflow.custom import Component

from langflow.inputs import MessageTextInput, DropdownInput
from langflow.template import Output
from langflow.schema import Data
from youtube_transcript_api import YouTubeTranscriptApi

class YouTubeTranscriptionComponent(Component):
display_name = "YouTube Transcription"
description = "Transcribe YouTube video using youtube-transcript-
api"
icon = "video"
inputs = [
MessageTextInput(
name="video_url",
display_name="YouTube Video URL",
info="URL of the YouTube video to transcribe.",
),
DropdownInput(
name="language",
display_name="Language",
options=["Portuguese", "English", "Spanish"],
info="Language of the transcription.",
),
]

outputs = [
Output(display_name="Transcription", name="transcription",
method="transcribe_video"),
]

LANGFLOW 67
 def transcribe_video(self) -> Data:
video_url = self.video_url
language = self.language
video_id = self.extract_video_id(video_url)
language_code = self.get_language_code(language)
transcript = self.get_transcription(video_id, language_code)

return Data(data={"transcription": transcript})

def extract_video_id(self, url: str) -> str:

"""
Extract the video ID from the YouTube URL.
"""
import re
pattern = r'(?:v=|\/)([0-9A-Za-z_-]{11}).*'
match = re.search(pattern, url)
if match:
return match.group(1)
raise ValueError("Invalid YouTube URL")

def get_language_code(self, language: str) -> str:

"""
Convert language name to language code.
"""
language_mapping = {
"Portuguese": "pt",
"English": "en",
"Spanish": "es",
}
return language_mapping.get(language, "en")

def get_transcription(self, video_id: str, language_code: str) ->

str:
"""
Get the transcription for the given video ID using youtube-
transcript-api.
"""
try:
transcript_list = YouTubeTranscriptApi.get_transcript(video_id,
languages=[language_code])
transcript = ' '.join([entry['text'] for entry in
transcript_list])
return transcript
except Exception as e:
return str(e)

Salvamos clicando em “Check & Save”.

LANGFLOW 68
 Agora temos nosso próprio componente de transcrição de vídeos do
Yo u t u b e . E l e e s t á u t i l i z a n d o a b i b l i o t e c a d o p y t h o n c h a m a d a
youtube_transcript_api, então, ela precisa estar instalada. Caso não esteja, basta
utilizar:

pip install youtube-transcript-ai

Para testar, basta executar o componente e ver os resultados do

processamento clicando no ícone de um olho ao lado do conector “Transcription” na
saída do componente.

Para compartilharmos esse componente precisamos clicar nas reticências no

menu superior do componente e acessar a opção “Download”. Para salvar o
componente e usar em SEUS projetos clique em “Salvar”. Se quiser compartilhar na
loja de componentes do Lang ow, chamada Lang ow Store, você só precisar criar
uma chave de API para ela antes.

O arquivo referente ao componente é em formato JSON. Para incorporar um

compnente novo ao seu menu de componentes, precisa acessar seu menu basta
retornar a tela principal do Lan ow, onde visualizamos
todos os projetos e clicarmos no ícone para
importarmos o arquivo JSON do novo componente.

Na aba de componentes da página de projetos

você vai encontrar os componentes importados e Salvos.
E na sua janela de criação de uxos você encontrará uma
nova categoria chamada “Saved”, de onde poderá ver seu novo componente de
Transcrição do Youtube.

LANGFLOW 69
fl
fl
fl
fl
8.2 - Criando um Componente de Geração de Imagem no
Dall-E

Utilizar um modelo gerador de imagens pode ser muito útil no propósito de

criar sistemas multi-agentes. Esse componente, até o momento não está presente de
forma nativa no Lang ow. Por essa razão, vamos criar um componente
personalizado (customizado) que acione a API do Dall-E, da OpenAI e faça a criação
de uma imagem.

Existem vários parâmetros necessários para esses geradores de imagem, você

pode acessar a documentação do Dall-E que está em sua versão 3, neste endereço:
https://openai.com/index/dall-e-3.

O que é comum a esses geradores é o fato de serem são “text-to-image”, ou

seja, são baseados em prompts. É claro que um melhor prompt direciona a
construção de uma imagem mais acertiva. Vamos inicialmente criar o componente
que receberá o prompt para enviar ao modelo e depois falaremos sobre usar um
modelo LLM para gerar prompts melhores para o gerador de imagem.

1 - Vamos começar arrastando para nossa área principal um Custom

Component

LANGFLOW 70
fl
 2 - Vamos abrir o editor de código do componente e entrar com o seguite
código python:

from langflow.custom import Component

from langflow.inputs import MessageTextInput, SecretStrInput,
BoolInput
from langflow.template import Output
from langflow.schema.message import Message
from openai import OpenAI

class DallEImageGenerator(Component):
display_name = “Dall-E Image Generator"
description = “Generates an image using the OpenAI Dall-E model
from a text prompt."
icon = "image"

inputs = [
MessageTextInput(
name="prompt",
display_name="Text Prompt",
info=“Entre com o prompt para gerar a imagem",
),
SecretStrInput(
name="openai_api_key",
display_name="OpenAI API Key",
info="The OpenAI API Key to use for the OpenAI model.",
advanced=False,
value="OPENAI_API_KEY",
),
BoolInput(
name="activate_image_generation",
display_name="Activate Image Generation",
info="Toggle to activate or deactivate image
generation.",
),
]

outputs = [
Output(display_name="Generated Image", name="generated_image",
method="generate_image"),
]

def generate_image(self) -> Message:

if not self.activate_image_generation:
self.status = "Image generation is deactivated."

LANGFLOW 71
 return Message(text="Image generation is deactivated.")

prompt = self.prompt
openai_api_key = self.openai_api_key
client = OpenAI(api_key=openai_api_key)

try:
response = client.images.generate(
model="dall-e-3",
prompt=prompt,
size="1792x1024",
quality="standard",
n=1,
)

image_url = response.data[0].url
self.status = f"{image_url}"
return Message(text=image_url)

except Exception as e:
error_message = f"Failed to generate image: {str(e)}"
self.status = error_message
return Message(text=error_message)

3 - Salvamos o código, renomeamos o componente clicando duas vezes no

seu título e pronto:

LANGFLOW 72
 Lembre-se de clicar no botão “Save” do menu suspenso do componente para
que seu componente esteja disponível para utilização em outros projetos.

O código desse componente customizado foi gerado usando um modelo LLM

(veremos como fazer isso) e ajustado com base das sugestões do repositório github
do usuário Mumunha (https://github.com/mumunha).

8.3 - Componente para Salvar o Resultado em Arquivo

Vamos criar um compoente que permita salvar o resultado de uma ação em

um arquivo MarkDown. Extremamente útil quando queremos que nossos agentes
gerem relatórios, escrevam posts, documentos, etc.

Semelhante ao que zemos antes, precisamos arrasar um Custom

Component e entrar com o código no editor:

from langflow.custom import Component

from langflow.io import MessageTextInput, Output
from langflow.schema import Data

class SaveToMarkdownComponent(Component):
display_name = "Save to Markdown"
description = "Saves the input text to a Markdown file."
icon = "file-alt"

inputs = [
MessageTextInput(
name="input_text",
display_name="Input Text",
info="Text to be saved in the Markdown file.",
),
MessageTextInput(
name="file_name",
display_name="File Name",
info="Name of the Markdown file.",
),
]

outputs = [

LANGFLOW 73
fi
 Output(display_name="Status", name="status",
method="save_to_markdown"),
]

def save_to_markdown(self) -> Data:

input_text = self.input_text
file_name = self.file_name

# Save the input_text to a Markdown file

with open(file_name, 'w', encoding='utf-8') as md_file:
md_file.write(input_text)

status_message = f"Text saved to {file_name}"

self.status = status_message
return Data(data={"status": status_message})

Salve seu novo componente para utilizar em outros projetos.

8.4 - Uma Super Ajuda na Criação de Componentes

Customizados

É claro que criar um componente novo envolve programação, como vimos no

tópico anterior, mas não quer dizer que eu não possa pedir uma ajuda dos modelos
de LLM para criar esse código python, não é mesmo?

Vamos acessar o endereço https://chatgpt.com/gpts para ter acesso a

algumas versões customizadas do ChatGPT, que incluem conhecimentos extras
sobre determinados assuntos mais especí cos.

LANGFLOW 74
fi
 Ao buscarmos por “lang ow”, a primeira opção que apareceu foi a versão
“Lang ow Componente Helper”, criada por um dos criados do Lang ow (Gabriel L
F Almeida); basta clicarmos sobre ela, escolher “Start Chat” para sermos levados ao
ambiente do ChatGPT mas com um conhecimento profundo de componentes no
Lang ow.

Nesse ambiente de chat eu entrei com o seguinte prompt para criar o

transcritor de vídeos do YouTube:

Por favor, quero criar um componente customizado que receba uma

url de vídeo do youtube e faça toda a transcrição do vídeo
utilizando o script youtube-transcript-api. Inclua um seletor
do tipo drop down que permita escolher o idioma do vídeo entre
Português, Inglês e Espanhol

O ChatGPT customizado me forneceu o código do componente que eu levei

para dentro da janela de código do componente customizado do Lang ow. É claro
que nem sempre funciona de primeira e pode ser necessário solicitar alterações e
correções para o modelo, mas é de grande ajuda. ;)

LANGFLOW 75
fl
fl
fl
fl
fl
 Capitulo 9

Fluxos ou Agentes?

Um uxo desenvolvido no Lang ow pode ser visto como um agente,

especialmente quando con gurado para realizar tarefas autonomamente com o uso
de outras ferramentas e interagir com o ambiente conforme as instruções de nidas.
Esses uxos processam entradas, aplicam lógica e algoritmos especí cos, e geram
saídas, permitindo a automação de diversas tarefas. Cada componente do uxo
desempenha uma função especí ca, contribuindo para o comportamento global do
agente. Ao integrar diferentes componentes, um uxo no Lang ow opera de forma
inteligente, percebendo entradas, processando dados e executando ações de acordo
com seus objetivos prede nidos. Vamos explorar essa ideia em mais detalhes.

9.1 - O que é um Agente?

Na computação, o conceito de agente é amplamente utilizado para descrever

uma entidade que interage com seu ambiente de maneira autônoma e inteligente.
Um agente é uma entidade capaz de perceber seu ambiente através de sensores e
agir sobre ele por meio de atuadores. Em termos mais práticos, isso signi ca que
um agente pode coletar informações de seu entorno, processar essas informações,
tomar decisões com base nelas e realizar ações para atingir determinados objetivos.

Um exemplo clássico de agentes físicos pode ser encontrado nos robôs, que
possuem sensores como câmeras, microfones e detectores de temperatura, que lhes
permitem perceber o ambiente. Eles também possuem atuadores, como motores e
braços mecânicos, que lhes permitem interagir sicamente com o mundo. Esses
robôs podem ser programados para realizar uma variedade de tarefas, desde a
navegação em um espaço até a manipulação de objetos, tudo isso de forma
autônoma, com base nas percepções que recebem e nas decisões que tomam.

Em termos de software, um agente pode ser de nido como um programa ou

um conjunto de programas que recebem entradas de dados, processam essas
informações e realizam ações com base nesse processamento. Por exemplo, um

LANGFLOW 76
fl
fl
fi
fi
fi
fl
fl
fi
fi
fl
fi
fi
fi
fl
 agente de software pode ser um chatbot que interage com usuários humanos. Esse
chatbot percebe a entrada do usuário através de mensagens de texto, processa essa
entrada utilizando técnicas de processamento de linguagem natural (NLP), decide a
melhor resposta e, nalmente, envia uma mensagem de volta ao usuário.

Fonte: Basa (2018)

A capacidade de tomar decisões autônomas é uma característica crucial dos

agentes. Eles são projetados para operar com um certo grau de independência, o que
signi ca que não precisam de intervenção humana constante para funcionar. Eles
podem adaptar seu comportamento com base nas mudanças no ambiente, aprender
com experiências passadas e até mesmo otimizar suas ações para alcançar melhores
resultados. Essa autonomia e capacidade de adaptação fazem dos agentes uma
ferramenta poderosa em diversas aplicações, desde sistemas de recomendação
personalizados até controle industrial e automação doméstica. Em suma, na
computação, um agente é uma entidade que utiliza suas habilidades de percepção,
processamento e ação para interagir de forma inteligente e autônoma com seu
ambiente, alcançando objetivos especí cos de maneira e ciente e e caz.

9.2 - Fluxos no Lang ow como Agentes

No contexto do Lang ow, um uxo é uma sequência de componentes

interconectados que processam dados e executam ações com base em uma lógica
prede nida. Cada componente no uxo atua como uma unidade funcional,
realizando tarefas especí cas e contribuindo para o objetivo geral do uxo. Assim, o
uxo completo pode ser considerado um agente que percebe entradas (inputs),
processa essas entradas utilizando regras e algoritmos de nidos, e gera saídas
(outputs).

LANGFLOW 77
fl
fi
fi
fi
fi
fl
fl
fi
fl
fl
fi
fi
fi
fl
 Essa estrutura modular permite que cada parte do uxo seja con gurada e
ajustada individualmente, garantindo exibilidade e e ciência na execução das
tarefas. Em essência, um uxo no Lang ow atua como um agente inteligente,
integrando a percepção de entradas, o processamento de dados e a geração de saídas
para cumprir seus objetivos de maneira autônoma e e caz.

9.3 - Características de um Agente em um Fluxo Lang ow

1 - Percepção do Ambiente: O uxo pode receber dados de entrada de várias

fontes, como entradas de usuário, APIs externas, bases de dados, etc.

2 - Processamento e Decisão: Dentro do uxo, diferentes componentes

processam os dados recebidos, aplicam algoritmos e regras para tomar decisões. Por
exemplo, um componente pode analisar texto para detectar sentimentos, enquanto
outro pode chamar uma API para obter informações adicionais.

3 - Ação: Com base nas decisões tomadas, o uxo pode realizar ações
especí cas, como responder ao usuário, armazenar dados, fazer chamadas de API,
etc.

Exemplo de um Fluxo como Agente

Vamos considerar um exemplo prático de um uxo no Lang ow que funciona

como um agente de atendimento ao cliente:

RECEBENDO ENTRADAS PROCESSAMENTO AÇÃO

• Um componente de
processamento de
linguagem natural
analisa a consulta para
entender a intenção do
O fluxo recebe uma usuário. O fluxo gera uma resposta
consulta do usuário, que com as informações
pode ser uma pergunta solicitadas e a envia de
sobre um produto. • Outro componente volta ao usuário
verifica uma base de
dados para encontrar
informações relevantes
sobre o produto
mencionado.

LANGFLOW 78
fi
fl
fl
fl
fl
fl
fl
fi
fi
fl
fl
fl
fl
fi
 No Lang ow, podemos criar um uxo com componentes de diferentes tipos
como: Input, recebe dados do usuário; LLM que processa a linguagem natural para
entender a intenção; Database que consulta uma base de dados; Chat Output ou
Save File, que gera e envia uma resposta ao usuário.

Esses componentes são conectados em uma sequência lógica que de ne o

comportamento do agente, podendo ter vários caminhos decididos de acordo com as
condições encontradas.

9.4 - Crew AI - Um aliado poderoso!

O Crew AI (https://www.crewai.com) é um
framework incrível criado pelo brasileiro João Moura
(https://github.com/joaomdmoura) para facilitar o
desenvolvimento e a coordenação de sistemas
multiagentes. Em um sistema multiagente, múltiplos
agentes independentes interagem e cooperam para
alcançar objetivos comuns ou resolver problemas
complexos. Esses agentes podem comunicar-se entre si, tomar decisões autônomas
e adaptar-se ao ambiente em tempo real.

1 - Coordenação de Agentes: Crew AI fornece ferramentas para coordenar a

atividade de vários agentes, permitindo que eles trabalhem juntos de maneira
e ciente.

2 - Comunicação entre Agentes: Os agentes podem trocar informações e

coordenar suas ações, facilitando a resolução de problemas que requerem
colaboração.

3 - Autonomia e Adaptação: Cada agente é autônomo e pode adaptar-se ao

ambiente com base em novas informações e mudanças contextuais.

4 - Escalabilidade: Crew AI é escalável, permitindo adicionar mais agentes

conforme necessário para aumentar a capacidade do sistema.

LANGFLOW 79
fi
fl
fl
fi
 Utilizar Crew AI integrado com Lang ow é uma abordagem poderosa para
construir sistemas multiagentes so sticados. A capacidade de criar uxos que
coordenam e integram múltiplos agentes autônomos permite o desenvolvimento de
soluções mais robustas e e cientes para problemas complexos.

Para instalar o Crew AI podemos utilizar o pip e ter Python >= 3.10 e
<=3.13:

# Install the main crewAI package

pip install crewai

# Install the main crewAI package and the tools package

# that includes a series of helpful tools for your agents
pip install 'crewai[tools]'

9.5 - Planejanto seus Agentes

Agentes, tarefas e ferramentas são os três partes do agente Crew AI.

a) Agente

Um agente é de nido por três parâmetros principais:

Papel: Sua função

Objetivo ou Meta: O que o agente precisa fazer
Contexto ou Trajetória: O histórico (backstory) do agente

Vamos a um exemplo do agente “Frodo Baggins”:

LANGFLOW 80
fi
fi
fi
fl
fl
 PAPEL META CONTEXTO

Frodo é um hobbit humilde, relutante, mas

corajoso, que foi incumbido da missão de
levar o Um Anel à Montanha da Perdição e
Destruir o Um Anel destruí-lo para derrotar o Lorde das
Portador do
na Montanha da
Anel Trevas, Sauron. Ele deve liderar a jornada,
Perdição
tomar decisões críticas e delegar tarefas
aos seus companheiros para garantir o
sucesso da missão.

b) Tarefas

Uma tarefa é de nida com os seguintes parâmetros:

Descrição: os detalhes da tarefa

Saída Esperada: o resultado que se espera com a conclusão da tarefa
Agente Atribuído: o agente responsável por executar a tarefa
Permissão para Delegar: se tarefa pode ser distribuída em subtarefas

Vamos a um exemplo de tarefa denominada “Recuperar o Anel” :

Descrição Saída Esperada Agente Permite

Delegação

O Anel
Frodo deve liderar a missão para levar o
destruído na
Um Anel à Montanha da Perdição e
Montanha da
destruí-lo. Durante a jornada, ele deve Frodo
Perdição, o
manter comunicação constante com Sam Baggins
grupo retorna
para suporte moral e logístico. Frodo Sim
em segurança,
deve delegar tarefas a Aragorn e Legolas
todas as
para defender o grupo de ameaças
unidades
iminentes, enquanto Gandalf fornece
informadas e
orientação estratégica e mágica.
alinhadas.

c) Ferramentas

As ferramentas são recursos que os agentes podem usar para alcançar os

objetivos das tarefas. Elas são de nidas de forma independente dos agentes, o que
permite sua reutilização por diversos agentes.

Exemplo:
Sting (Espada de Frodo): Ferramenta de Frodo para defesa e combate próximo.

LANGFLOW 81
fi
fi
9.6 - Criando uma Equipe

Agentes:

Frodo: Portador do Anel - Meta: destruir o Um Anel.

Sam: Fiel companheiro - Meta: apoiar e proteger Frodo.
Aragorn: Protetor e líder de combate - Meta: proteger Frodo e combater inimigos.
Legolas: Arqueiro e batedor - Meta: realizar reconhecimento e eliminar ameaças à
distância.

Tarefas:

Frodo: Levar o Um Anel à Montanha da Perdição e destruí-lo.

Sam: Proteger e motivar Frodo durante a jornada.
Aragorn: Defender o grupo de ameaças e liderar em batalhas.
Legolas: Realizar reconhecimento e eliminar inimigos à distância.

Ferramentas:

Espada Sting: Ferramenta de Frodo para defesa e combate próximo.

Pão de Lembas: Ferramenta para Frodo e Sam se manterem nutridos e
energizados durante a jornada.
Espada Andúril: Ferramenta de Aragorn para combate.
Arco e Flechas de Legolas: Ferramenta de Legolas para ataques à distância.

LANGFLOW 82
Capítulo 10

Criando um Sistema com Múltiplos

Agentes

Neste capítulo vamos utilizar componentes Crew AI para criar sistemas com
múltiplos agentes no Lang ow. Baseando-se os conceitos que vimos no capítulo
anterior sabemos que precisamos criar um planejamento de nossos agentes, suas
tarefas e ferramentas necessárias. No lang ow, precisaremos de componentes do
tipo Agent Crew, Componentes do tipo Sequential Task e, para agrupar esses
agentes em equipes, usaremos o Sequential Crew.

PAPEL META (GOAL) CONTEXTO (BACKSTORY)

(ROLE)
Pesquisador Pesquise no Google para Pesquisar sempre foi sua
encontrar informações para praia. Você consegue encontrar
concluir a tarefa. coisas rapidamente na web por
causa de suas habilidades.

Editor Você deve editar as Você é o editor do periódico

informações fornecidas pelo mais conceituado do mundo.
pesquisador para torná-las
mais compreensíveis e não
conter informações
enganosas.

Comediante Você escreve conteúdo cômico Sua ocupação formal é

com base nas informações Comediante-Chefe. Você escreve
fornecidas pelo editor. piadas, faz standup comedy e
escreve artigos engraçados.

Nesse projeto (baseado no exemplo da documentação do Lan ow), criaremos

uma equipe (crew) que será capaz de, dado um determinado tema, realizar buscas
na internet, extrair os pontos principais, redigir um post, revisar e até dar uma
pitada de humor ao texto.

LANGFLOW 83
fl
fl
fl
10.1 - Agentes Envolvidos

Arraste os 3 componentes do tipo CrewAI Agent

para sua área principal e con gure conforme a tabela
acima, dando seus papéis, metas e contextos.

Se analisarmos as metas cuidadosamente,

veremos que o agente Pesquisador precisa executar
uma busca no Google, então, precisaremos dar a ele
essa ferramenta de busca (Tools).

Vamos adicionar o componente Search API.

Você precisará escolher o Egine Google e inserir suas
credenciais obtidas na plataforma Search API.
(https://www.searchapi.io/).

Conecte a saída do componente Search API ao conector “Tools” do agente

Pesquisador.

Agora vamos ao modelo de linguagem (LLM). Os 3 agentes (Pesquisador,

Editor e Comediante) precisarão ser ligados a um LLM para compreenderem suas
identidades e suas tarefas. Vamos arrastar o component OpenAI e inserir nossas
credenciais e conectá-lo aos três agentes:

LANGFLOW 84
fi
LANGFLOW 85
10.2 - Tarefas dos Agentes

O principal nessa etapa é ligar cada agente a um

componente Sequential Task, e informar uma “saída
esperada” do da tarefa executada. Os conectores
“Agent” serão ligados a seus respectivos agentes.

No campo “Expected Output” (saída esperada)

de cada tarefa, coloque o seguinte:

1 - Task do Pequisador: Marcadores e pequenas

frases sobre o tópico da pesquisa

2 - Task do Editor: Pequenos parágrafos e

marcadores com o conteúdo corrigido.

3 - Task do Comediante: Um pequeno blog sobre o assunto

Utilizaremos os conectores “Description” (obrigatório) para receber

informações de prompt formatados que criaremos em seguida e os conectores
“Task” serão utilizados para conectar uma tarefa a outra, uma vez que um agente
está dependendo de informações produzidas por outro.

Note que a saída de cada Sequential Task está conectada ao próximo.

LANGFLOW 86
LANGFLOW 87
 10.3 - Criando os Prompts

Vamos primeiramente criar um

componente Input Text que chamaremos de
“Tópico”, que será o assunto principal da
postagem que queremos realizar. O valor
de nido aqui será enviado para formatação
dos prompts.

Cada componente de tarefa precisa de

uma “description” que forneceremos por meio do componente Prompt. Os três
prómpts necessários serão criados com os seguintes templates:

Prompt para a Task do Pesquisador: Tópico: {topic} Crie um documento sobre

este documento.

Prompt para a Task do Editor: Tópico: {topic} Revise este documento.

Prompt para a Task do Comediante: Tópico: {topic} Crie uma postagem de blog
divertida sobre este tópico.

Conect a saída do Input Text (Tópico) à variável “topic" que criamos nos
prompts e conecte-os aos conectores “Description” de suas tarefas.

LANGFLOW 88
fi
LANGFLOW 89
 10.4 - Sequential Crew

O componente Sequential Crew representa nosso grupo de agentes,

de nindo como eles devem colaborar e as tarefas que devem executar. Arraste esse
componente para nosso uxo e conecte a saída do último agente (Comediante) ao
conector “Tasks” dele.

Adicione também um componente Chat Output ao nal do uxo para

visualizar os resultados da execução do uxo na tela de Playground.

Pronto, agora você tem uma equipe com 3 agentes criando posts com uma
pitada de humor baseado no tópico que de nir pra eles.

Que tal acrescentar mais integrantes a sua equipe? E se juntarmos um agente

que cria imagens com o Dalle? Já zemos esse componente por aqui, seria
necessário apenas um agente Artista Digital que recebesse a tarefa e a ferramenta
que criamos anteriormente.

LANGFLOW 90
fi
fl
fl
fi
fi
fi
fl
 Capítulo 11

Monitorando sua Aplicação com

LangWatch

O desenvolvimento de sistemas multi-agentes com Lang ow que zemos até

agora permite a criação de uxos complexos e dinâmicos, agentes interagem e
colaboram para alcançar objetivos especí cos. No entanto, garantir que esses
sistemas funcionem corretamente e de maneira e ciente pode ser um desa o. É aqui
que entra o Langwatch (www.langwatch.ai), uma ferramenta essencial para
monitorar e analisar a execução de uxos no Lang ow.

O Langwatch proporciona uma visão detalhada de cada etapa da execução dos

uxos, registrando todas as atividades dos agentes, suas decisões, e as interações
com o ambiente. Esse monitoramento detalhado é crucial para identi car e corrigir
problemas, otimizar o desempenho dos agentes e garantir que eles estejam
cumprindo suas metas conforme planejado.

Uma das principais funcionalidades do Langwatch é a capacidade de registrar

logs de execução. Esses logs fornecem um histórico completo das ações dos agentes,
incluindo as decisões tomadas, os dados processados e as interações com outros
componentes do sistema. Com essas informações, os desenvolvedores podem
analisar o comportamento dos agentes em diferentes cenários e identi car padrões
ou anomalias que possam indicar problemas.

Por exemplo, imagine um uxo onde um agente responsável pela coleta de

dados deve interagir com várias fontes de informação. Se esse agente falhar em

LANGFLOW 91
fl
fl
fl
fl
fi
fi
fl
fl
fi
fi
fi
fi
 coletar os dados corretamente, o Langwatch pode ajudar a identi car onde ocorreu a
falha, seja em uma decisão errada do agente, uma falha na comunicação com a fonte
de dados ou um erro na lógica do uxo. Com essa análise detalhada, poderemos
ajustar o uxo ou corrigir o agente para melhorar a e ciência e a precisão da coleta
de dados.

Além dos logs de execução, o Langwatch oferece ferramentas de visualização

de dados que facilitam a compreensão do comportamento dos agentes. Grá cos e
dashboards interativos permitem monitorar métricas importantes em tempo real,
como o tempo de resposta dos agentes, a quantidade de dados processados, e a taxa
de sucesso das tarefas. Essas visualizações ajudam a identi car rapidamente
quaisquer desvios de desempenho e a tomar medidas corretivas antes que os
problemas se tornem críticos.

Outra vantagem do Langwatch é a capacidade de gerar relatórios detalhados

sobre a execução dos uxos. Esses relatórios podem incluir estatísticas sobre o
desempenho dos agentes, análises de erros e sugestões de melhorias. Para equipes
de desenvolvimento e operações, esses relatórios são valiosos para o planejamento
de atualizações e otimizações dos sistemas multi-agentes, além de fornecerem uma
documentação precisa do estado atual do sistema.

O uso do Langwatch não se limita apenas à detecção e correção de

problemas. Ele também é uma ferramenta poderosa para a otimização contínua dos
uxos. Ao analisar os dados de execução e os relatórios gerados, os desenvolvedores
podem identi car áreas onde os agentes podem ser melhorados, seja ajustando a
lógica de decisão, re nando os algoritmos de processamento ou otimizando a
interação com outros componentes. Esse ciclo contínuo de monitoramento, análise
e otimização é fundamental para manter os sistemas multi-agentes e cientes e
adaptáveis às mudanças no ambiente ou nos requisitos do usuário.

O processo para integrar o Langwatch a seu uxo de agentes Lang ow é bem

simples:

1 - Acesse o site langwatch.ai e clique na opção “Get Acess” (superior

direito). Ou acesse diretamente: https://app.langwatch.ai

LANGFLOW 92
fl
fl
fi
fi
fl
fl
fl
fi
fi
fi
fl
fi
fi
 2 - Crie sua conta utilizando sua conta GMail ou Github (processo mais
simpli cado). A conta gratuita permite gerenciar apenas um projeto, se precisar de
mais projetos, pode escolher um plano de pagamento adequado.

3 - Crie o projeto para integração tipo Python com OpenAI e de na o nome e

clique em “next"

4 - Na tela de Dashboard que abrir, capture a API Key gerada para realizar a
integração:

LANGFLOW 93
fi
fi
 5 - Crie um arquivo .env em seu editor de textos com o seguinte conteúdo:

6 - Inicie o Lang ow com o seguinte comando. Se estiver com o lang ow

iniciado, precisa nalizar e reiniciar.

langflow run —env-file .env

Agora, abra ou crie um novo uxo e interaja com o seu modelo pelo Playground,
acesse o Langwatch e veri que que os dados da sua interação agora esão registrados
em “Messages" podemos visualizar:

LANGFLOW 94
fi
fl
fi
fl
fl
 Ao clicar sobre uma interação, podemos ver toda a cadeia de comunicação
entre os componentes, os tempos de execução, as mensagens trafegadas

Com a análise dessas informações podemos encontrar caminhos para

melhorar nossos uxos, analisar as respostas que o modelo está retornando ao
nosso usuário, o nível de assertividade da resposta obtida.

LANGFLOW 95
fl
Capítulo 12

Realizando Deploy de Seus Projetos

Colocar em produção um uxo desenvolvido no Lang ow envolve alguns

passos importantes para garantir que o uxo funcione corretamente em um
ambiente real.

Existem diversas formas de disponibilizar um uxo do Lang ow e o primeiro

passo é acessarmos a opção API dentro de seu uxo.

Várias abas com códigos de integração do seu projeto Lang ow a outras

aplicações externas são exibidas nessa janela.

Run cURL - Realiza uma requisição direta da linha de comandos do terminal

usando o curl
PythonAPI - Código de aplicação Python para requisições via API
JS API - Código em linguagem Javascript
Python Code - Código de aplicação Python
Chat Widget HTML - Código para uma simples implementação direto em
uma página HTML de um site

LANGFLOW 96
fl
fl
fl
fl
fl
fl
fl
 Tweaks - Referem-se a ajustes ou personalizações, parâmetros como as
chaves de API, que você pode aplicar aos componentes
Se você acionar a opção “Tweaks” (no canto superior da janela de códigos) os
parâmetros ocultos serão adionados ao script gerado para integração. Tenha cuidado
ao compartilhar um código gerado assim porque as chaves de API carão visíveis.

Para implementar um chatbot que criou no Lang ow em um site, a maneira

mais simples é utilizar o widget, pois basta copiar o código e inserir entre as tags
<body> e </body> de seu arquivo HTML.

Assim, ao carregar o site, um widget de chat será automaticamente

carregado:

<script src="https://cdn.jsdelivr.net/gh/logspace-ai/
langflow-embedded-chat@v1.0.3/dist/build/static/js/
bundle.min.js""></script>

<langflow-chat
window_title="Chatbot Pirata"
flow_id="cb8c5e6e-92cf-45e8-86f0-dd4403051e6c"
host_url="http://localhost:7860"

LANGFLOW 97
fl
fi
 ></langflow-chat>

Para projetos de agentes que executem tarefas mas não há interação com
usuário ou mesmo que quem em execução por tempo indeterminado, o ideal pode
ser criar um script python. Vamos da execução de um desses uxos feitos no
Lang ow:

Primeiro, certi que-se de que você o o equipameno que vai executar nosso
programa python tenha a versão superior a 3.11 instalada. Depois, basta criarmos
um script com o código que copiamos na aba Python Code do uxo desejado, nesse
exemplo será nosso uxo Gerador de Posts:

from langflow.load import run_flow_from_json

TWEAKS = {
"URL-U7U4k": {},
"ParseData-sin6M": {},
"Prompt-nF5Q9": {},
"TextInput-q1Nk4": {},
"ChatOutput-mVIYJ": {},
"OpenAIModel-b7BFj": {},
"CustomComponent-IPecb": {}
}

result = run_flow_from_json(flow="BlogWriter.json",
input_value="message",
fallback_to_env_vars=True, #
False by default
tweaks=TWEAKS)

Esse script precisa estar na mesma pasta onde salvei o uxo exportado do
Lang ow (BlogWriter.json). Lembre-se de que os valores TWEAKS estão ocultados
por padrão, mas você precisará preenchê-los no seu script:

LANGFLOW 98
fl
fl
fl
fi
fi
fl
fl
fl
 Na aba “Python API” você pode marcar o seletor para que esses valores sejam
preenchidos e assim poderá levá-los ao seu script python. No meu caso, ele cou
assim:

TWEAKS = {
"URL-U7U4k": {
"urls": [
"https://ai.google/why-ai/"
]
},
"ParseData-sin6M": {
"sep": "\n",
"template": "{text}"
},
"Prompt-nF5Q9": {
"instructions": "",
"references": "",
"template": "Agora você é um redator de blog
especialista em colunas que tratam sobre Inteligência
Artificial para pessoas leigas. Escreva um texto para um
blog com base nas referências {references} e com os estilos
de escrita dos exemplos abaixo.\n\n---\n\n{instructions}
\n\n\n"
},
"TextInput-q1Nk4": {
"input_value": "Sempre descreva os recursos técnicos de
maneira didática"
},
"ChatOutput-mVIYJ": {
"data_template": "{text}",
"input_value": "",
"sender": "Machine",
"sender_name": "AI",
"session_id": "",
"store_message": True
},
"OpenAIModel-b7BFj": {
"input_value": "",
"json_mode": False,
"max_tokens": 1000,
"model_kwargs": {},
"model_name": "gpt-4o",
"openai_api_base": "",
"openai_api_key": "sk-proj-XXXXXXXXXXXXXXXXXXXXX",
"output_schema": {},

LANGFLOW 99
fi
 "seed": 1,
"stream": False,
"system_message": "",
"temperature": 0.1
},
"CustomComponent-IPecb": {
"file_name": "posts.md",
"input_text": ""
}
}

2 - Substitua os valores no seu script python e salve. Quando zemos esse

uxo nos primeiros capítulos, a nossa saída foi testada apenas no Playground, mas
agora queremos que ele execute fora de um ambiente de chatbot, então adicionei
um componente personalizado ao nal dele para que gere um arquivo do tipo
MarkDown(.md), assim teremos os resultados da execução desse uxo.

Mensagem Final

Espero que este material seja importante no seu processo de aprendizado

pois foi organizado para que você tivesse um início mais suave. Mas não é tudo que
podemos fazer com essas ferramentas.

Acompanhe regularmente as evoluções desse framework, seus novos

componentes pois tudo está acontecendo muito rápido. Participe da vibrante
comunidade do Lang ow, aprenda e ensine através do repositório o cial no Github
e no canal o cial no Discord: https://discord.gg/EqksyE2EX9

LANGFLOW 100
fl
fi
fl
fi
fl
fi
fi
 Referências e Links

Chroma DB: https://github.com/chroma-core/chroma

Crew AI - https://www.crewai.com

CrewAI Documentation: https://docs.crewai.com/

Google AI Studio - https://aistudio.google.com

Gungor Basa. Intelligent agents. Website, April 2018.

LangChain - https://python.langchain.com

Lang ow Documentation: https://docs.lang ow.org/

Lang ow + DataStax: https://lang ow.datastax.com

LMSYS Chatbot Arena https://arena.lmsys.org

MACEDO, Sandeco; Prompts em Ação: Engenharia de Prompts para Leigos; 2024

Ministério da Saúde; Governo do Brasil, 2024: https://www.gov.br/saude/pt-br/

centrais-de-conteudo/publicacoes/cartilhas/2024/dengue-pro ssionais-da-aps-

orientacoes-para-diagnostico-e-manejo-clinico/@@download/ le Open AI Dall-E:

https://openai.com/index/dall-e-3

Open AI - GPT’s - https://chatgpt.com/gpts

Search API: https://www.searchapi.io/

LANGFLOW 101
fl
fl
fl
fl
fi
fi
 Sandro Moreira
@SandroEnsinaAI

LANGFLOW 102