Interaja com seus documentos usando Retrieval-Augmented Generation (RAG)

Imagine ter um chatbot pessoal que pode responder perguntas diretamente de seus documentos – sejam eles PDFs, artigos de pesquisa ou livros. Com a Geração Aumentada de Recuperação (RAG), isso não só é possível, mas também simples de implementar. Neste tutorial, aprenderemos como criar um chatbot que interaja com seus documentos, como PDFs, usando Geração Aumentada de Recuperação (RAG). Nós usaremos Groq para encontrar o significado do modelo de linguagem, Croma como uma loja de vetores também Gradio equipamento do usuário.

No final, você terá um chatbot que poderá responder perguntas diretamente de seus documentos, reter o contexto da sua conversa e fornecer respostas curtas e precisas.

O que é geração aumentada de recuperação (RAG)?

A Geração Aumentada de Recuperação (RAG) é uma arquitetura de IA que melhora os recursos de Modelos de Linguagem em Grande Escala (LLMs) integrando sistemas de recuperação de informações. Este sistema recupera dados relevantes de fontes externas, fornecendo ao LLM informações terrestres para gerar respostas mais precisas e contextualmente apropriadas. Ao combinar recursos de geração de LLM com recuperação de dados em tempo real, o RAG reduz imprecisões e garante informações atualizadas sobre conteúdo gerado por IA.

O que é necessário

1. Instalação do Python: Certifique-se de que o Python 3.9+ esteja instalado em seu sistema.
2. Chave API Groq: Cadastre-se para uma conta Groq e gere uma chave API:
   • Visite o console Groq.
   • Navegue até Chaves de API e crie uma nova chave.
   • Copie sua chave de API para usar no projeto.

Dependência: Instale as bibliotecas necessárias:

pip install langchain langchain-community langchain-groq gradio sentence-transformers PyPDF2 chromadb

Essas bibliotecas ajudarão no processamento de linguagem, criação de interface de usuário, integração de modelos, gerenciamento de PDF e gerenciamento de banco de dados de vetores.

Baixando recurso PDF

Neste tutorial, usaremos um PDF disponível publicamente que contém informações sobre doenças, seus sintomas e tratamentos. Baixe o PDF e salve-o no diretório do seu projeto (você pode usar qualquer pdf).

Passo 1: Extrair Texto para PDF

Usaremos PyPDF2 para extrair texto de PDF:

from PyPDF2 import PdfReader

def extract_text_from_pdf(pdf_path):
    reader = PdfReader(pdf_path)
    text = ""
    for page in reader.pages:
        text += page.extract_text()
    return text

pdf_path="diseases.pdf"  # Replace with your PDF path
pdf_text = extract_text_from_pdf(pdf_path)

Etapa 2: divida o texto em fragmentos

Documentos longos são divididos em pedaços menores e gerenciáveis ​​para processamento.

from langchain.text_splitter import RecursiveCharacterTextSplitter

def split_text_into_chunks(text, chunk_size=2000, chunk_overlap=200):
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=chunk_size,
        chunk_overlap=chunk_overlap
    )
    return text_splitter.split_text(text)

text_chunks = split_text_into_chunks(pdf_text)

Etapa 3: Crie uma loja vetorial com Chroma

Incorporaremos fragmentos de texto usando um modelo pré-treinado e os armazenaremos em Croma banco de dados de vetores.

from langchain.embeddings import SentenceTransformerEmbeddings
from langchain.vectorstores import Chroma

embedding_model = SentenceTransformerEmbeddings(model_name="all-MiniLM-L6-v2")

vector_store = Chroma(
    collection_name="disease_info",
    embedding_function=embedding_model,
    persist_directory="./chroma_db"
)

vector_store.add_texts(texts=text_chunks)

Etapa 4: execute o modelo de linguagem Groq

Para usar o modelo de linguagem do Groq, defina sua chave de API e comece ChatGroq por exemplo.

import os
from langchain_groq import ChatGroq

os.environ["GROQ_API_KEY"] = 'your_groq_api_key_here'  # Replace with your API key

llm = ChatGroq(model="mixtral-8x7b-32768", temperature=0.1)

Etapa 5: crie um tópico de recuperação de bate-papo

Sobre LangChain Cadeia de Recuperação Conversacionalpodemos conectar o modelo de linguagem e o banco de dados vetorial.

from langchain.chains import ConversationalRetrievalChain

retrieval_chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=vector_store.as_retriever(topk=3),
    return_source_documents=True
)

Etapa 6: implementar a lógica do chatbot

Explicamos a lógica de salvar o histórico do chat e responder.

conversation_history = []

def get_response(user_query):
    response = retrieval_chain({
        "question": user_query,
        "chat_history": conversation_history
    })
    conversation_history.append((user_query, response['answer']))
    return response['answer']

Etapa 7: Construa a interface do usuário com Gradio

Por fim, crie uma interface Gradio para interagir com o chatbot.

import gradio as gr

def chat_interface(user_input, history):
    response = get_response(user_input)
    history.append((user_input, response))
    return history, history

with gr.Blocks() as demo:
    chatbot = gr.Chatbot()
    state = gr.State([])
    with gr.Row():
        user_input = gr.Textbox(show_label=False, placeholder="Enter your question...")
        submit_btn = gr.Button("Send")
    submit_btn.click(chat_interface, inputs=[user_input, state], outputs=[chatbot, state])

Usando o código

Salve o texto como aplicativo.py e correr

python app.py

Viva! Você terminou. A interface do Gradio será lançada, permitindo que você interaja com seu documento.

Mas por que você está parado aqui? Você pode ir mais longe tentando construir qualquer uma das seguintes funcionalidades no chatbot.

1. Loja de vetores avançada: Use outros sites de vetores como Milvus ou Pinecone para escalabilidade.
2. Modelos bem projetados: Experimente modelos Groq ajustados para precisão específica de domínio.
3. Suporte para vários scripts: Amplie o sistema para lidar com mais documentos.
4. Melhor gerenciamento de conteúdo: Melhore a lógica do chat para gerenciar melhor os longos históricos de chat.
5. IU personalizada: Crie uma interface de usuário altamente sofisticada com estilo e recursos avançados.

Parabéns! Você construiu com sucesso um chatbot baseado em documentos usando Groq e LangChain. Experimente o desenvolvimento e construa algo incrível! 🚀

Recursos:

2. LangChain (
3. Groq (

Além disso, não se esqueça de nos seguir Twitter e junte-se ao nosso Estação telefônica de novo LinkedIn Gracima. Não se esqueça de participar do nosso SubReddit de 65k + ML.

🚨 Recomende uma plataforma de código aberto: Parlant é uma estrutura que muda a forma como os agentes de IA tomam decisões em situações voltadas para o cliente. ^(Promovido)

Vineet Kumar é estagiário de consultoria na MarktechPost. Atualmente, ele está cursando seu bacharelado no Instituto Indiano de Tecnologia (IIT), Kanpur. Ele é um entusiasta do aprendizado de máquina. Ele está interessado em pesquisas e desenvolvimentos recentes em Deep Learning, Visão Computacional e áreas afins.