Construindo aplicativos da Web com tecnologia de IA com RAG

Construindo aplicativos da Web com tecnologia de IA com RAG

A Geração Aumentada de Recuperação (RAG) combina o poder de grandes modelos de linguagem (LLMs) com bases de conhecimento externas, permitindo respostas mais precisas e fundamentadas às consultas dos usuários. Neste artigo, exploraremos como construir uma aplicação web completa baseada em RAG, abrangendo desde a ingestão de dados até a implantação de uma interface funcional com tecnologia de IA.


---

O que é RAG?

RAG é uma técnica em que os LLMs são complementados com fontes externas de informação. Em vez de depender apenas do conhecimento codificado nos parâmetros do modelo, o RAG recupera blocos de dados relevantes de uma base de conhecimento e os passa para o modelo durante o processamento da consulta.

Por que usar RAG?

Precisão aprimorada: fornece respostas fundamentadas com base em informações atualizadas.

Alucinações reduzidas: limita a tendência do LLM de gerar respostas falsas, mas que parecem confiantes.

Personalização: adapte as respostas usando bases de conhecimento específicas do domínio (por exemplo, políticas da empresa, manuais de produtos).



---

Pré-requisitos

Antes de começar, certifique-se de ter o seguinte:

1. Python 3.8+ instalado.


2. Familiaridade com Flask e desenvolvimento web básico.


3. Acesso à API do OpenAI ou a um LLM local (por exemplo, Llama 2).




---

Etapa 1: Configurando seu ambiente

Crie um ambiente virtual e instale dependências:

# Crie um ambiente virtual
python3 -m venv venv
fonte venv/bin/activate # No Windows, use: venv\Scripts\activate

# Instalar dependências
pip instalar flask langchain openai faiss-cpu python-dotenv

Prepare um arquivo requirements.txt para facilitar a replicação:

frasco==2.2.5
cadeia longa == 0,0,305
openai==0,27,8
faiss-cpu==1.7.4
python-dotenv==1.0.0


---

Etapa 2: Preparando a Base de Conhecimento

Seu sistema RAG pode ingerir vários tipos de dados, como arquivos de texto, PDFs ou conteúdo de sites. Para este exemplo, começaremos com um arquivo .txt simples.

Carregando e fragmentando texto

Use langchain.text_splitter.RecursiveCharacterTextSplitter para dividir texto grande em pedaços gerenciáveis ​​para recuperação.

Crie um arquivo chamado data_utils.py:

de langchain.text_splitter importar RecursiveCharacterTextSplitter

def load_text(caminho_do_arquivo: str) -> str:
"""Carregar texto bruto de um arquivo."""
com open(file_path, "r", encoding="utf-8") como f:
retornar f.read()

def chunk_text(texto: str, chunk_size=500, sobreposição=50) -> lista:
"""Divida o texto em pedaços para melhor indexação."""
divisor = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=overlap)
retornar divisor.split_text(texto)

Coloque seu arquivo de texto (por exemplo, knowledge_base.txt) em uma pasta data/ e carregue-o e divida-o em partes usando as funções acima.


---

Etapa 3: Criando um repositório de vetores

Use o FAISS para incorporar e armazenar os blocos de texto para uma pesquisa de similaridade eficiente.

Incorporação e armazenamento de dados

Crie um arquivo chamado embeddings_utils.py:

de langchain.embeddings importar OpenAIEmbeddings
de langchain.vectorstores importar FAISS

def build_faiss_index(pedaços, chave_de_api, caminho_de_salvamento="faiss_index.pkl"):
"""Incorpore pedaços de texto e armazene-os em um índice FAISS."""
embeddings = OpenAIEmbeddings(api_key)
vectorstore = FAISS.from_texts(pedaços, embeddings)
vectorstore.save_local(caminho_de_salvamento)
retornar vectorstore

def load_faiss_index(api_key, save_path="faiss_index.pkl"):
"""Carregar um índice FAISS existente."""
embeddings = OpenAIEmbeddings(api_key)
retornar FAISS.load_local(save_path, embeddings)


---

Etapa 4: Integrando RAG com LangChain

A cadeia RetrievalQA da LangChain facilita a consulta ao armazenamento de vetores e a recuperação de blocos relevantes para gerar respostas.

Configurando a corrente RAG

Crie um arquivo chamado rag_pipeline.py:

de langchain.chains importar RetrievalQA
de langchain.llms importar OpenAI

def create_rag_chain(vectorstore, api_key):
"""Crie um pipeline RAG usando um vectorstore e OpenAI."""
recuperador = vectorstore.as_retriever(search_kwargs={"k": 3})
cadeia = RetrievalQA.from_chain_type(
llm=OpenAI(chave_api=chave_api),
retriever=recuperador,
tipo_de_cadeia="coisas"
)
corrente de retorno


---

Etapa 5: Construindo o Backend do Flask

Agora, integre tudo em um aplicativo web Flask.

Configurando o Flask

Em app.py:

do frasco importar Flask, solicitar, jsonify
importar sistema operacional
de src.data_utils importar load_text, chunk_text
de src.embeddings_utils importar build_faiss_index, load_faiss_index
de src.rag_pipeline importar create_rag_chain

# Carregar variáveis ​​de ambiente
de dotenv importar load_dotenv
load_dotenv()
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

aplicativo = Flask(__nome__)

# Inicializar componentes
vectorstore = Nenhum
rag_chain = Nenhum

@app.antes_da_primeira_solicitação
def configuração():
"""Inicialize o armazenamento de vetores e a cadeia RAG."""
loja de vetores global, rag_chain

# Carregar e processar texto
texto = load_text("dados/base_de_conhecimento.txt")
pedaços = chunk_text(texto)

# Construir ou carregar índice FAISS
se os.path.existe("faiss_index.pkl"):
vectorstore = load_faiss_index(CHAVE_API_OPENAI)
outro:
vectorstore = build_faiss_index(pedaços, OPENAI_API_KEY)

# Crie a cadeia RAG
rag_chain = criar_rag_chain(armazenamento_vetorial, CHAVE_API_ABERTA)

@app.route("/ask", métodos=["POST"])
def perguntar():
"""Lidar com consultas de usuários."""
consulta = request.json.get("consulta", "")
se não consultar:
retornar jsonify({"error": "Nenhuma consulta fornecida"}), 400

resposta = rag_chain.run(consulta)
retornar jsonify({"resposta": resposta})

se __nome__ == "__principal__":
app.run(host="0.0.0.0", porta=5000, debug=True)


---

Etapa 6: Adicionando o Front-End

Interface HTML

Crie um front-end simples em templates/index.html:

<!DOCTYPE html>
<html>
<cabeça>
<title>Sistema RAG</title>
</cabeçalho>
<corpo>
Pergunte à nossa base de conhecimento
<textarea id="query" placeholder="Digite sua pergunta..."></textarea>
<button onclick="ask()">Perguntar</button>
<p id="resposta"></p>

<script>
função ask() {
const consulta = document.getElementById("consulta").valor;
buscar("/perguntar", {
método: "POST",
cabeçalhos: { "Content-Type": "application/json" },
corpo: JSON.stringify({ consulta }),
})
.então((res) => res.json())
.então((dados) => {
document.getElementById("resposta").innerText = dados.resposta;
});
}
</script>
</corpo>
</html>


---

Etapa 7: Testando o aplicativo

1. Execute o aplicativo Flask:

aplicativo python.py


2. Acesse http://localhost:5000 no seu navegador.


3. Faça perguntas sobre sua base de conhecimento, como:

O que o documento diz sobre políticas de reembolso?




---

Etapa 8: Escalonamento e implantação

Coloque o aplicativo em contêineres com o Docker para implantação.

Use Gunicorn com Nginx para escalabilidade de produção.

Para implantações em larga escala, considere bancos de dados vetoriais hospedados na nuvem, como Pinecone ou Weaviate.



---

Conclusão

Este guia percorreu as principais etapas da criação de um sistema de geração aumentada de recuperação (RAG), desde a ingestão e incorporação de dados até o atendimento de consultas de usuários por meio de uma interface web. Com essa base, você pode expandir o sistema para incluir bases de conhecimento de múltiplas fontes, designs front-end avançados e implantações mais escaláveis.

Fique ligado para artigos mais aprofundados sobre tópicos avançados do RAG, incluindo integração de data lakes empresariais e suporte multilíngue.


---

Este é o conteúdo completo do primeiro artigo. Avise-me se quiser o conteúdo completo dos outros artigos ou se quiser exemplos personalizados para seções específicas!