Chatea con tus documentos mediante la generación de recuperación aumentada (RAG)

Imagine tener un chatbot personal que pueda responder preguntas directamente desde sus documentos, ya sean archivos PDF, trabajos de investigación o libros. Con generación aumentada de recuperación (TRAPO), esto no sólo es posible sino también sencillo de implementar. En este tutorial, aprenderemos cómo crear un chatbot que interactúe con sus documentos, como archivos PDF, usando Recuperación-Generación Aumentada (RAG). usaremos Groq para la inferencia del modelo de lenguaje, croma como almacén de vectores, y Gradio para la interfaz de usuario.

Al final, tendrá un chatbot capaz de responder preguntas directamente desde sus documentos, mantener el contexto de su conversación y brindar respuestas concisas y precisas.

¿Qué es la generación aumentada de recuperación (RAG)?

Recuperación-Generación Aumentada (RAG) es una arquitectura de inteligencia artificial que mejora las capacidades de los modelos de lenguajes grandes (LLM) mediante la integración de un sistema de recuperación de información. Este sistema obtiene datos relevantes de fuentes externas, proporcionando al LLM información fundamentada para generar respuestas más precisas y contextualmente apropiadas. Al combinar las capacidades generativas de los LLM con la recuperación de datos en tiempo real, RAG reduce las imprecisiones y garantiza información actualizada en el contenido generado por IA.

Requisitos previos

1. Instalación de Python: Asegúrese de que Python 3.9+ esté instalado en su sistema.
2. Clave API de Groq: Regístrese para obtener una cuenta de Groq y genere una clave API:
   • Visita la consola Groq.
   • Navegar a Claves API y crear una nueva clave.
   • Copie su clave API para usarla en el proyecto.

Dependencias: Instale las bibliotecas necesarias:

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

Estas bibliotecas ayudarán con el procesamiento del lenguaje, la creación de la interfaz de usuario, la integración de modelos, el manejo de PDF y la gestión de bases de datos vectoriales.

Descarga del recurso PDF

Para este tutorial, utilizaremos un PDF disponible públicamente que contiene información sobre enfermedades, sus síntomas y curas. Descargue el PDF y guárdelo en el directorio de su proyecto (puede utilizar cualquier PDF).

Paso 1: extraer texto del PDF

Usaremos PyPDF2 para extraer texto del 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)

Paso 2: divide el texto en fragmentos

Los documentos largos se dividen en partes más pequeñas y manejables para su procesamiento.

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)

Paso 3: crea una tienda de vectores con Chroma

Incrustaremos los fragmentos de texto utilizando un modelo previamente entrenado y los almacenaremos en un croma base de datos vectorial.

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)

Paso 4: Inicialice el modelo de lenguaje Groq

Para utilizar el modelo de lenguaje de Groq, configure su clave API e inicialice el ChatGroq instancia.

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)

Paso 5: cree la cadena de recuperación conversacional

Con LangChain Cadena de recuperación conversacionalpodemos vincular el modelo de lenguaje y la base de datos vectorial.

from langchain.chains import ConversationalRetrievalChain

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

Paso 6: implementar la lógica del chatbot

Definimos la lógica para mantener el historial de conversaciones y generar respuestas.

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']

Paso 7: cree la interfaz de usuario con Gradio

Finalmente, crea una interfaz Gradio para interactuar con el 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])

Ejecutando el código

Guarde el guión como aplicación.py y correr

python app.py

¡Viva! Ya terminaste. Se iniciará la interfaz de Gradio, permitiéndole chatear con su documento.

¿Pero por qué detenerse aquí? Puede ir más allá intentando crear cualquiera de las siguientes funcionalidades en el chatbot.

1. Tienda de vectores mejorada: Utilice otras bases de datos vectoriales como Milvus o Pinecone para lograr escalabilidad.
2. Modelos afinados: Experimente con modelos Groq ajustados para obtener precisión específica del dominio.
3. Soporte para múltiples documentos: Amplíe el sistema para manejar múltiples documentos.
4. Mejor manejo del contexto: Refina la lógica conversacional para gestionar mejor historiales de chat más largos.
5. Interfaz de usuario personalizada: Diseñe una interfaz de usuario más pulida con estilo y funciones avanzadas.

¡Felicidades! Ha creado con éxito un chatbot basado en documentos utilizando Groq y LangChain. ¡Experimenta con mejoras y construye algo increíble! 🚀

Recursos:

1. https://nios.ac.in/media/documents/SrSec314NewE/Lesson-29.pdf
2. Cadena Lang (https://www.langchain.com/)
3. Groq (https://groq.com/)

Además, no olvides seguirnos en Gorjeo y únete a nuestro Canal de telegramas y LinkedIn Grarriba. No olvides unirte a nuestro SubReddit de más de 65.000 ml.

🚨 Recomendar plataforma de código abierto: Parlant es un marco que transforma la forma en que los agentes de IA toman decisiones en escenarios de cara al cliente. ^(Promovido)

Vineet Kumar es pasante de consultoría en MarktechPost. Actualmente está cursando su licenciatura en el Instituto Indio de Tecnología (IIT), Kanpur. Es un entusiasta del aprendizaje automático. Le apasiona la investigación y los últimos avances en Deep Learning, Computer Vision y campos relacionados.