Para criar uma poderosa equipe de tarefas de IA usando o banco de dados Vector e o GRAQ para reembolso (RAG): guia passo a passo

Atualmente, três tópicos principais na IA são LLMS, RAG e detalhes da informação. Isso nos permite criar programas que sejam bons para o nosso uso. Este programa movido a IA, incluindo o vetor produzido pela IA e as respostas produzidas pela IA, tem aplicativos ao seu redor em diferentes indústrias. No suporte ao cliente, os botas de chat de AI retornam as respostas às informações no poder. Procedimentos jurídicos e financeiros se beneficiam da falta de documento e julgamento da IA. Os assistentes de saúde AI ajudam os médicos sobre pesquisa médica e negociações de drogas. As plataformas de aprendizado fornecem treinamento personalizado da empresa. O Mistquity usa notícias de fábrica de IA e testes a verdade. Desenvolvimento de software AI para código e correção de erro. Benefícios da pesquisa científica de revisões de livros mantidos pela IA. Esse método abre mais informações, que tornam a criação de conteúdo e parcerias pessoais em muitos domínios.

Nesta lição, construiremos uma poderosa equipe em inglês usando o trapo. O programa inclui o banco de dados vetorial (Chromadb) para manter e retornar materiais relevantes em inglês e a geração de TStraction movida a IA (API GROQ) para criar sistemáticos e envolvidos. Os gastos de uma tarefa incluem a publicação do texto do PDFS, mantendo as informações do banco de dados vetorial, retornou o conteúdo apropriado e para gerar detalhes da IA. O objetivo é desenvolver um professor ativo de inglês produzido pelos horários com base no tópico, impedindo informações anteriormente com precisão e contexto avançados.

Etapa 1: Instalando as bibliotecas necessárias

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

O PYPDF2 emite um texto de arquivos PDF, tornando -o útil para lidar com as informações com base no documento. O Groq é uma biblioteca para fornecer AI AI API do GROQ, permitindo o poder de reparar o texto avançado. Chromadb é um banco de dados vetorial projetado para o texto. Os Transformers-Transformers fabricam a incorporação de texto, o que ajuda a manutenção e a ganhar significado. O NLTK (Kit de ferramentas de linguagem ambiental) é uma biblioteca bem conhecida do texto da PNL do texto do texto, tokenwation e análise. O FPDF é uma falta de construção de luz e ilusão em documentos em PDF, permitindo que os sujeitos produzidos de maneira ordenada. Torch um programa de aprendizado profundo frequentemente usado para atividades de estudo de máquina, incluindo a geração de IA baseada em IA.

Etapa 2: Baixe os dados de tokenização do NLP

import nltk
nltk.download('punkt_tab')

Dados punkt_tab baixados usando o código acima. Nltk.download ('punkt_tab') descrevendo os dados necessários para encontrar a tokenização da frase. A tokenzação é distinguir o texto a ser sentenças ou palavras, o que é muito importante para quebrar os grandes corpos do processamento controlado e de retorno componentes.

Etapa 3: para definir o diretório de dados do 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 um diretório dedicado dos dados do NLTK. OS.GetCWD () é uma função das orientações práticas atuais, e o novo guia NLTK_DATA é criado dentro deles, mantendo os recursos da PNL. Nltk.data.path.appamMP (nltk_data_dir) O comando confirma que essas diretrizes acabam baixando detalhes do NLTK. O conjunto de dados punkt_tab, necessário para encontrar uma frase, ser baixado e armazenado na identificação especificada.

Etapa 4: Importar bibliotecas necessárias

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

Aqui, introduzimos todas as bibliotecas necessárias usadas ao longo de uma carta de redação. O SO é usado para o funcionamento do sistema de arquivos. A tocha é introduzida para tratar empregos mais profundos relacionados. Transformers-Transformers fornece uma produção fácil no texto. O Chromadb e seu módulo de prevenção de NumTum é uma biblioteca usada para gerenciar matrizes e a fusão de números. O PYPDF2 é usado para remover o texto dos PDFs. O FPDF permite documentos em PDF. Lru_cacha é usado para a liberação de trabalhos de cache. Grim do serviço de IA produz respostas como humano. O NLTK fornece operações da NLP e enviado para_to é importado diretamente para distinguir o texto em frases. O UUID produz IDs exclusivos e a variabilidade natural do load_dotenv.

Etapa 5: Carregamento de impacto ambiental e chave da API

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

#or manually retrieve key from  and add it here

Usando o código acima, faremos o upload, variações naturais do arquivo .env. Load_dotenv () O trabalho lê as variações naturais do arquivo .env e disponibiliza na área de Python. API_KEY é encontrado usando o OS.geEgenv ('API_KEY'), confirma as teclas da API seguras sem removê -lo no script. A chave é armazenada no OS.enving[“GROQ_API_KEY”]Por que contou nos recentes apelos da API.

Etapa 6: explicando a categoria de dados do vetor

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 seção descreve o VectorIdatabase em contato com o Chrodb para manter e restaurar o registro com base no texto. O __nit __ () O trabalho está analisando o banco de dados, criando o diretório crônico persistente da última vez. O modelo de Sentencansform (minilm-l6-v2) cria um texto motivacional, que converte as informações de texto em envio de valores adequados e suportados. Add_Text () O trabalho divide o texto da instalação em frases e divida -o em pequenos pedaços antes de mantê -los no banco de dados do vetor. O _CRABE_TUNKS () O trabalho garante que o texto seja bem separado, tornando-o mais eficaz. Recuperação () O trabalho faz uma pergunta e retorna as chaves mantidas com o mesmo suporte de suporte.

Etapa 7: Usando a lição de AI com a aderência

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 seção, Groqgenerator, é responsável pela produção de cursos ingleses movidos a IA. Contata -se do modelo Groq AI com a chamada da API. O __ni __ () o trabalhador blasfemas o gerador usando um modelo Mixtral-8×7-32768, projetado para IA. Exerre_forn () O funcionário está obtendo um título e retornou informações como instalação, envio imediatamente e enviá -las para a API GROQ para o Geral Geral Groq. O sistema de IA restaura um estudo formal com definições e exemplos, que podem ser mantidos ou indicados.

Etapa 8: Combinando a recuperação de vetores e a geração 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

A classe acima, RagenglishTearcher, inclui o VectratedAtAbase e os elementos do programa GruqGenator para criar um RAG). FUND () A função retorna o conteúdo certo do vetor Datota e transmite ao GroqGenerator para produzir uma lição formal. Lru_cache (maxsize = 32) A intenção de decoração atinge 32 cursos produzidos anteriormente para melhorar a eficiência, evitando uma integração repetida.

Em conclusão, criamos com sucesso a geração de recuperação em inglês (CHROMADB), movida a um texto, pode emitir texto a partir de PDFs, manter as informações relevantes sistematicamente, encontrar informações adequadas e gerar cursos detalhados. O ministro nos fornece envolvidos, a formação do estado e os cursos personalizados através da inclusão de retornos eficazes e da AI relevante da AI Respostas. Essa abordagem dos guiarias os alunos recebem lições externas precisas, informativas e bem organizadas necessárias para criar conteúdo de handico. O programa pode ser aumentado, continuando os módulos de aprendizado adicionais, para melhorar o funcionamento dos dados ou as melhores respostas de IA para tornar o processo de ensino muito e inteligente.

Gastar Folheto no canto aqui. Além disso, não se esqueça de seguir Sane e junte -se ao nosso Estação de telégrafo incluindo LinkedIn grtópico. Não se esqueça de se juntar ao nosso 70k + ml subreddit.

🚨 Conheça o trabalho: um código aberto aberto com várias fontes para verificar o programa difícil AI ^(Atualizado)