cerebro-vip INEMA.CLUB
início › INEMA.IA CONCEITOS

Tutorial completo sobre LangChain, cobrindo conceitos fundamentais e…

INEMA.IA CONCEITOS · 2025-10-22 · ~7 min · ver no Telegram ↗

INEMA

A seguir está o guia completo para criar um Chatbot com LangChain + Supabase + OpenAI, capaz de ler PDFs, armazenar embeddings e responder perguntas com base neles.

1. O que este projeto faz⌗

O sistema:

  1. Lê arquivos PDF e extrai o texto.
  2. Divide o conteúdo em trechos menores.
  3. Cria embeddings (representações vetoriais do texto).
  4. Armazena esses embeddings no Supabase Vector Database.
  5. Permite que o usuário faça perguntas sobre o conteúdo.
  6. O GPT responde com base nos trechos mais relevantes encontrados no Supabase.

2. Instalações necessárias⌗

Execute no terminal:

pip install langchain openai supabase faiss-cpu pypdf

3. Configuração do Supabase⌗

No painel do Supabase:

  1. Crie um projeto novo.
  2. Vá em Table Editor → New Table → nomeie como documents.
  3. Crie as colunas:
Nome Tipo Descrição
id uuid Primary key (auto gerado)
content text Texto original do documento
metadata jsonb Metadados (ex: nome do arquivo)
embedding vector(1536) Vetor de embeddings do OpenAI
  1. Habilite a extensão vector no Supabase SQL Editor:

create extension if not exists vector;

4. Código completo (LangChain + Supabase)⌗

```from langchain.document_loaders import PyPDFLoader from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain.embeddings import OpenAIEmbeddings from langchain.vectorstores import SupabaseVectorStore from langchain.llms import OpenAI from langchain.chains import RetrievalQA from supabase import create_client

CONFIGURAÇÕES⌗

SUPABASE_URL = "SEU_PROJETO.supabase.co ↗" SUPABASE_KEY = "SUA_CHAVE_API_SUPABASE" OPENAI_KEY = "SUA_CHAVE_API_OPENAI"

1. Conectar ao Supabase⌗

supabase = create_client(SUPABASE_URL, SUPABASE_KEY)

2. Carregar PDF⌗

loader = PyPDFLoader("seu_arquivo.pdf") documents = loader.load()

3. Dividir texto em blocos⌗

splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100) docs = splitter.split_documents(documents)

4. Criar embeddings⌗

embeddings = OpenAIEmbeddings(api_key=OPENAI_KEY)

5. Criar o vetor no Supabase⌗

vector_store = SupabaseVectorStore.from_documents( docs, embeddings, client=supabase, table_name="documents", )

print("✅ Embeddings enviados com sucesso para o Supabase!")

6. Criar modelo de linguagem e retrieval⌗

llm = OpenAI(api_key=OPENAI_KEY, temperature=0) retriever = vector_store.as_retriever(search_kwargs={"k": 3}) qa_chain = RetrievalQA.from_chain_type(llm=llm, retriever=retriever)

7. Fazer perguntas⌗

while True: pergunta = input("\nPergunte algo sobre o PDF (ou 'sair'): ") if pergunta.lower() == "sair": break resposta = qa_chain.run(pergunta) print("\nResposta:", resposta)```

5. Funcionamento passo a passo⌗

  1. PyPDFLoader lê o conteúdo do PDF.
  2. TextSplitter divide o texto em blocos menores.
  3. OpenAIEmbeddings transforma cada bloco em vetores (1536 dimensões).
  4. SupabaseVectorStore envia os vetores para o Supabase.
  5. Quando você faz uma pergunta, ele busca os vetores mais próximos (semântica) e gera a resposta com base neles.

6. Resultado esperado⌗

```✅ Embeddings enviados com sucesso para o Supabase!

Pergunte algo sobre o PDF (ou 'sair'): Qual é o tema principal do documento? Resposta: O documento aborda o impacto da inteligência artificial na medicina moderna...```

7. Próximos passos⌗

  • Substituir o PDF por múltiplos arquivos, carregando cada um com metadados diferentes.
  • Criar uma interface web com Streamlit ou FastAPI.
  • Usar LangServe para transformar o chatbot em uma API.
  • Integrar com Make.com ou n8n para automação de consultas.

Vamos criar um exemplo prático e completo em Python usando LangChain + OpenAI + PDF, simulando um chatbot que responde perguntas com base em um documento.

1. Objetivo⌗

Criar um sistema que:

  1. Leia um arquivo PDF.
  2. Converta o conteúdo em vetores (usando embeddings).
  3. Armazene no banco vetorial (FAISS).
  4. Permita que o usuário faça perguntas sobre o conteúdo.
  5. Gere respostas contextuais usando o GPT (via LangChain).

2. Instalação das bibliotecas⌗

Execute no terminal:

pip install langchain openai faiss-cpu pypdf

3. Código completo do chatbot com PDF⌗

```from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain.document_loaders import PyPDFLoader from langchain.embeddings import OpenAIEmbeddings from langchain.vectorstores import FAISS from langchain.chains import RetrievalQA from langchain.llms import OpenAI

1. Carregar o PDF⌗

loader = PyPDFLoader("seu_arquivo.pdf") # Substitua pelo nome do seu arquivo documents = loader.load()

2. Dividir o texto em partes menores⌗

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100) docs = text_splitter.split_documents(documents)

3. Criar embeddings (representação vetorial do texto)⌗

embeddings = OpenAIEmbeddings(api_key="SUA_CHAVE_API_AQUI")

4. Criar banco vetorial (FAISS)⌗

db = FAISS.from_documents(docs, embeddings)

5. Criar o modelo de linguagem⌗

llm = OpenAI(temperature=0, api_key="SUA_CHAVE_API_AQUI")

6. Conectar o LLM ao retriever (sistema RAG)⌗

qa = RetrievalQA.from_chain_type( llm=llm, retriever=db.as_retriever(search_kwargs={"k": 3}), # busca os 3 trechos mais relevantes chain_type="stuff" )

7. Fazer perguntas⌗

while True: pergunta = input("\nPergunte algo sobre o PDF (ou 'sair' para encerrar): ") if pergunta.lower() == "sair": break resposta = qa.run(pergunta) print("\nResposta:", resposta)```

4. O que acontece passo a passo⌗

  1. Carregamento – o PyPDFLoader lê o conteúdo de cada página.
  2. Divisão – o texto é dividido em partes (chunks) para melhorar o contexto.
  3. Embeddings – cada trecho é convertido em vetores numéricos.
  4. FAISS – cria um índice para busca semântica rápida.
  5. RetrievalQA – conecta o banco vetorial ao GPT.
  6. Perguntas – quando você faz uma pergunta, o GPT busca os trechos mais relevantes e responde com base neles.

5. Resultado esperado⌗

Quando você rodar o script, verá algo assim:

Pergunte algo sobre o PDF (ou 'sair' para encerrar): Qual é o tema principal do documento? Resposta: O documento trata sobre o uso de inteligência artificial na saúde...

6. Próximos passos (opcionais)⌗

  • Substituir FAISS por Supabase ou Pinecone para busca vetorial em nuvem.
  • Adicionar Streamlit ou Gradio para criar uma interface web.
  • Integrar LangChain Agents para permitir ações automáticas (buscar sites, fazer cálculos, etc.).

LangChain é uma biblioteca de código aberto criada para facilitar o desenvolvimento de aplicações baseadas em Modelos de Linguagem (LLMs), como o GPT. Ele funciona como uma ponte entre o modelo de IA e os dados, APIs ou fluxos de lógica da aplicação.

1. O que é o LangChain⌗

LangChain é um framework que organiza a forma como os LLMs interagem com dados e ferramentas externas. Ele permite que você construa sistemas de IA capazes de:

  • Fazer análises complexas de informações;
  • Conectar bancos de dados e fontes externas;
  • Executar ações (como buscas, cálculos ou consultas);
  • E lembrar do contexto de conversas anteriores.

Em resumo, ele transforma um LLM em algo muito mais poderoso do que apenas um “chatbot”: torna-o um agente inteligente com memória, lógica e acesso a dados reais.

2. Como o LangChain funciona⌗

O funcionamento se baseia em componentes modulares que podem ser combinados para criar fluxos complexos:

a) Modelos (LLMs)⌗

São os motores de linguagem — como GPT, Claude, Gemini ou Mistral — que geram respostas.

b) Prompts⌗

São as instruções passadas ao modelo. O LangChain ajuda a estruturar e reutilizar prompts, tornando-os dinâmicos e adaptáveis.

c) Memória⌗

Permite que o sistema “lembre” de interações anteriores ou informações do usuário, como um histórico de conversa.

d) Chains (Cadeias)⌗

São fluxos lógicos de execução. Por exemplo:

  1. Fazer uma pergunta ao usuário;
  2. Buscar dados em uma API;
  3. Passar o resultado ao LLM;
  4. Retornar uma resposta final.

e) Agents (Agentes)⌗

São versões avançadas das “chains” que decidem sozinhos o que fazer — por exemplo, se devem chamar uma API, usar uma calculadora, ou gerar texto.

f) Retrievers e VectorStores⌗

Permitem integrar dados externos, como PDFs, bancos de dados ou documentos. Eles são usados em sistemas RAG (Retrieval-Augmented Generation) — onde o LLM consulta dados antes de responder.

3. Exemplo prático⌗

Imagine um assistente que responde perguntas sobre documentos da empresa:

  1. O LangChain lê e “transforma” os documentos em vetores (usando embeddings).
  2. Quando o usuário faz uma pergunta, ele busca os trechos mais relevantes.
  3. O LLM (por exemplo, GPT-4) usa esses trechos para gerar uma resposta precisa.

Isso cria um chat inteligente com base nos dados da empresa.

4. Ecossistema do LangChain⌗

  • LangSmith: para depurar e monitorar o comportamento do seu app de IA.
  • LangServe: para implantar suas aplicações como APIs.
  • LangGraph: para criar fluxos complexos com lógica condicional e memória.

5. Exemplos de uso⌗

  • Chatbots empresariais com memória e busca em documentos;
  • Ferramentas de atendimento automatizado;
  • Sistemas de análise de relatórios;
  • Aplicativos que conectam IA a bancos de dados, planilhas ou APIs.

6. Exemplo simples de código⌗

```from langchain.llms import OpenAI from langchain.chains import LLMChain from langchain.prompts import PromptTemplate

template = "Explique em termos simples o que é {tema}." prompt = PromptTemplate(input_variables=["tema"], template=template) llm = OpenAI(api_key="SUA_API_KEY_AQUI") chain = LLMChain(llm=llm, prompt=prompt)

resposta = chain.run("inteligência artificial") print(resposta)```

LangChain Interface com LLMs

chatgpt.com ↗

1

Recursos

↑ voltar ao topo · ver no Telegram ↗