Creación de un tutor con IA utilizando una base de datos Vector y Groq para la generación acuática de recuperación (RAG): guía paso a paso

Actualmente, tres temas de tendencia en la implementación de AI son LLMS, TRAPOy bases de datos. Estos nos permiten crear sistemas adecuados y específicos para nuestro uso. Este sistema impulsado por IA, que combina una base de datos vectorial y respuestas generadas por IA, tiene aplicaciones en varias industrias. En la atención al cliente, los chatbots de IA recuperan las respuestas de la base de conocimiento dinámicamente. Los sectores legal y financiero se benefician de la resumen de documentos y la investigación de casos impulsados ​​por la IA. Los asistentes de IA de la salud ayudan a los médicos con investigación médica e interacciones de drogas. Las plataformas de aprendizaje electrónico brindan capacitación corporativa personalizada. El periodismo utiliza IA para resumen de noticias y verificación de hechos. El desarrollo de software aprovecha la IA para la asistencia de codificación y la depuración. La investigación científica se beneficia de las revisiones de literatura impulsadas por la IA. Este enfoque mejora la recuperación del conocimiento, automatiza la creación de contenido y personaliza las interacciones del usuario en múltiples dominios.

En este tutorial, crearemos un tutor de inglés con AI usando trapo. El sistema integra una base de datos vectorial (ChromAdB) para almacenar y recuperar materiales de aprendizaje de idioma inglés relevantes y generación de texto con IA (API Groq) para crear lecciones estructuradas y atractivas. El flujo de trabajo incluye extraer texto de PDFS, almacenar conocimiento en una base de datos vectorial, recuperar contenido relevante y generar lecciones detalladas de IA. El objetivo es construir un tutor de inglés interactivo que genera dinámicamente lecciones basadas en temas al tiempo que aprovecha el conocimiento previamente almacenado para una mayor precisión y relevancia contextual.

Paso 1: Instalación de las bibliotecas necesarias

!pip install PyPDF2
!pip install groq
!pip install chromadb
!pip install sentence-transformers
!pip install nltk
!pip install fpdf
!pip install torch

PYPDF2 extrae texto de archivos PDF, lo que lo hace útil para manejar información basada en documentos. Groq es una biblioteca que proporciona acceso a la API AI de Groq, que permite capacidades avanzadas de generación de texto. ChromAdB es una base de datos vectorial diseñada para recuperar el texto de manera eficiente. Los transformadores de oraciones generan incrustaciones de texto, lo que ayuda a almacenar y recuperar la información de manera significativa. NLTK (kit de herramientas de lenguaje natural) es una biblioteca NLP bien conocida para preprocesamiento de texto, tokenización y análisis. FPDF es una biblioteca liviana para crear y manipular documentos PDF, lo que permite que las lecciones generadas se guarden en un formato estructurado. La antorcha es un marco de aprendizaje profundo que se usa comúnmente para tareas de aprendizaje automático, incluida la generación de texto basada en IA.

Paso 2: descarga de datos de tokenización de NLP

import nltk
nltk.download('punkt_tab')

El conjunto de datos punkt_tab se descarga utilizando el código anterior. nltk.download (‘punkt_tab’) obtiene un conjunto de datos requerido para la tokenización de oraciones. La tokenización es dividir el texto en oraciones o palabras, lo cual es crucial para descomponer grandes cuerpos de texto en segmentos manejables para el procesamiento y la recuperación.

Paso 3: Configuración del directorio de datos NLTK

working_directory = os.getcwd()
nltk_data_dir = os.path.join(working_directory, 'nltk_data')

nltk.data.path.append(nltk_data_dir)
nltk.download('punkt_tab', download_dir=nltk_data_dir)

Configuraremos un directorio dedicado para los datos NLTK. La función OS.GetCwd () recupera el directorio de trabajo actual, y se crea un nuevo directorio nltk_data dentro de él para almacenar recursos relacionados con NLP. El comando nltk.data.path.append (nltk_data_dir) garantiza que este directorio almacene los conjuntos de datos NLTK. El conjunto de datos punkt_tab, requerido para la tokenización de oraciones, se descarga y almacena en el directorio especificado.

Paso 4: Importar bibliotecas requeridas

import os
import torch
from sentence_transformers import SentenceTransformer
import chromadb
from chromadb.utils import embedding_functions
import numpy as np
import PyPDF2
from fpdf import FPDF
from functools import lru_cache
from groq import Groq
import nltk
from nltk.tokenize import sent_tokenize
import uuid
from dotenv import load_dotenv

Aquí, importamos todas las bibliotecas necesarias utilizadas en todo el cuaderno. El sistema operativo se utiliza para las operaciones del sistema de archivos. La antorcha se importa para manejar tareas relacionadas con el aprendizaje profundo. Sentence-Transformers proporciona una manera fácil de generar incrustaciones a partir del texto. ChromAdB y su módulo Ingredding_Functions ayudan a almacenar y recuperar el texto relevante. Numpy es una biblioteca matemática utilizada para manejar matrices y cálculos numéricos. PYPDF2 se usa para extraer texto de PDFS. FPDF permite la generación de documentos PDF. LRU_CACHE se usa para almacenar en caché las salidas de la función para la optimización. Groq es un servicio de IA que genera respuestas humanas. NLTK proporciona funcionalidades de NLP, y Sent_Tokenize se importa específicamente para dividir el texto en oraciones. UUID genera IDS únicos, y Load_Dotenv Cargue las variables de entorno desde un archivo .env.

Paso 5: Variables de entorno de carga y tecla API

load_dotenv()
api_key = os.getenv('api_key')
os.environ["GROQ_API_KEY"] = api_key

#or manually retrieve key from https://console.groq.com/ and add it here

A través del código anterior, cargaremos variables de entorno desde un archivo .env. La función load_dotenv () lee variables de entorno del archivo .env y las pone a disposición del entorno Python. El API_KEY se recupera usando OS.Getenv (‘API_KEY’), asegurando la gestión de claves API seguras sin codificarla en el script. La tecla se almacena en OS.[“GROQ_API_KEY”]haciéndolo accesible para llamadas API posteriores.

Paso 6: Definición de la clase de base de datos Vector

class VectorDatabase:
    def __init__(self, collection_name="english_teacher_collection"):
        self.client = chromadb.PersistentClient(path="./chroma_db")
        self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
        self.embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")
        self.collection = self.client.get_or_create_collection(name=collection_name, embedding_function=self.embedding_function)

    def add_text(self, text, chunk_size):
        sentences = sent_tokenize(text, language="english")
        chunks = self._create_chunks(sentences, chunk_size)
        ids = [str(uuid.uuid4()) for _ in chunks]
        self.collection.add(documents=chunks, ids=ids)

    def _create_chunks(self, sentences, chunk_size):
        chunks = []
        for i in range(0, len(sentences), chunk_size):
            chunk = ' '.join(sentences[i:i+chunk_size])
            chunks.append(chunk)
        return chunks

    def retrieve(self, query, k=3):
        results = self.collection.query(query_texts=[query], n_results=k)
        return results['documents'][0]

Esta clase define una vectordatabase que interactúa con ChromAdB para almacenar y recuperar el conocimiento basado en texto. La función __init __ () inicializa la base de datos, creando un directorio persistente Chroma_DB para el almacenamiento a largo plazo. El modelo de SentenceTransformer (All-Minilm-L6-V2) genera incrustaciones de texto, que convierten la información textual en representaciones numéricas que se pueden almacenar y buscar eficientemente. La función add_text () divide el texto de entrada en oraciones y las divide en trozos más pequeños antes de almacenarlos en la base de datos Vector. La función _create_chunks () asegura que el texto esté correctamente segmentado, haciendo que la recuperación sea más efectiva. La función Remieve () toma una consulta y devuelve los documentos almacenados más relevantes en función de la similitud.

Paso 7: Implementación de la generación de lecciones de IA con Groq

class GroqGenerator:
    def __init__(self, model_name="mixtral-8x7b-32768"):
        self.model_name = model_name
        self.client = Groq()

    def generate_lesson(self, topic, retrieved_content):
        prompt = f"Create an engaging English lesson about {topic}. Use the following information:n"
        prompt += "nn".join(retrieved_content)
        prompt += "nnLesson:"

        chat_completion = self.client.chat.completions.create(
            model=self.model_name,
            messages=[
                {"role": "system", "content": "You are an AI English teacher designed to create an elaborative and engaging lesson."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=1000,
            temperature=0.7
        )
        return chat_completion.choices[0].message.content

Esta clase, GroqGenerator, es responsable de generar lecciones de inglés con IA. Interactúa con el modelo Groq AI a través de una llamada API. La función __init __ () inicializa el generador utilizando el modelo mixtral-8x7b-32768, diseñado para IA conversacional. La función Generate_lesson () toma un tema y recuperó el conocimiento como entrada, formatea un mensaje y lo envía a la API Groq para la generación de lecciones. El sistema AI devuelve una lección estructurada con explicaciones y ejemplos, que luego se pueden almacenar o mostrar.

Paso 8: Combinar la recuperación de vectores y la generación de IA

class RAGEnglishTeacher:
    def __init__(self, vector_db, generator):
        self.vector_db = vector_db
        self.generator = generator

    @lru_cache(maxsize=32)
    def teach(self, topic):
        relevant_content = self.vector_db.retrieve(topic)
        lesson = self.generator.generate_lesson(topic, relevant_content)
        return lesson

La clase anterior, RagenGlishTeacher, integra los componentes VectordAdatabase y GroqGenerator para crear un sistema de generación (RAG) de recuperación (RAG). La función Teach () recupera contenido relevante de la base de datos Vector y lo pasa al GroqGenerator para producir una lección estructurada. El decorador LRU_CACHE (MaxSize = 32) almacena en caché hasta 32 lecciones generadas previamente para mejorar la eficiencia al evitar los cálculos repetidos.

En conclusión, creamos con éxito un tutor en inglés con AI que combina una base de datos vectorial (ChromAdB) y el modelo de IA de Groq para implementar la generación de recuperación acuática (RAG). El sistema puede extraer texto de PDFS, almacenar el conocimiento relevante de manera estructurada, recuperar información contextual y generar lecciones detalladas dinámicamente. Este tutor proporciona lecciones atractivas, conscientes de contexto y personalizadas mediante la utilización de integridades de oraciones para recuperación eficiente y respuestas generadas por IA para el aprendizaje estructurado. Este enfoque garantiza que los alumnos reciban lecciones de inglés precisas, informativas y bien organizadas sin requerir la creación de contenido manual. El sistema se puede ampliar aún más integrando módulos de aprendizaje adicionales, mejorando la eficiencia de la base de datos o las respuestas de IA ajustados para que el proceso de tutoría sea más interactivo e inteligente.

Usar el Cuaderno de colab aquí. Además, no olvides seguirnos Gorjeo y únete a nuestro Canal de telegrama y LinkedIn GRsalpicar. No olvides unirte a nuestro 70k+ ml de subreddit.

🚨 Conocer Intellagent: Un marco de múltiples agentes de código abierto para evaluar un sistema de IA conversacional complejo ^{(Promocionado)}