Como muitos estudantes, eu não Desfrute de rolar através de PDFs sem fim. Eu faria se pudesse pular a leitura e apenas fazer perguntas ao meu livro. Então, naturalmente, fiz o que qualquer pessoa preguiçosa, mas resistente, faria: despejei todo o PDF em um LLM e comecei a fazer perguntas, orando a Deus para que as respostas fossem precisas.
Alerta de spoiler: Eles não estavam.
As respostas foram vagas, erradas ou simplesmente confusas. Foi quando eu percebi – grandes modelos de idiomas não são mágicos (chocantes, eu sei). Eles têm limites de contextoE encher um livro inteiro em um immediate é como tentar encaixar uma melancia em uma bolsa de ziplock.
Então eu comecei a cavar, e foi aí que encontrei o MVP actual: RAG (geração de recuperação de recuperação). Com RAG, em vez de alimentação de força tudo, você ensina onde Para olhar – e de repente, as respostas começam a fazer sentido
Por que grandes janelas de contexto realmente não ajudam (muito)
Você pode pensar: “Espere … mas modelos mais novos têm janelas de contexto massivas, certo? Isso não deveria corrigir o problema?”
Em teoria? Sim.
Na prática? Meh.
Mesmo com as janelas de contexto que se estendem até 100 mil tokens (que parecem enormes), você ainda está trabalhando com trade-offs:
-
Eles são caros de usar.
-
Eles geralmente truncaram ou comprimem informações.
-
E, a menos que seu immediate esteja perfeitamente estruturado (o que raramente é o caso), o modelo ainda acaba alucinando ou dando respostas genéricas.
É como pedir ao seu amigo que se lembre de cada palavra de um livro de 300 páginas e esperando que eles não estraguem os detalhes. Não é ideally suited.
Pano para o resgate
Rag-geração de recuperação de recuperação-é como dar ao seu LLM uma folha de dicas … mas realmente inteligente e direcionada.
Aqui está o fluxo:
- Você dividiu seu livro em pedaços menores
- Você armazena esses pedaços em um db de vetor.
- Quando um usuário faz uma pergunta, você não dá ao modelo o inteiro livro – apenas o partes mais relevantes.
- Então o LLM cria uma resposta sólida e informada usando apenasessas partes.
Menos ruído. Mais sinal. Muito melhores respostas.
Como é o oleoduto RAG?
Think about que você é o intermediário entre seu livro e seu modelo.
Seu trabalho é:
-
Divida o conteúdo → Quebre o livro em pedaços legíveis
-
Converta -os em vetores → usando um modelo de incorporação (coere)
-
Salve esses vetores → em um banco de dados vetorial (Pinecone)
-
Quando uma pergunta é feita:
- Converter a pergunta em um vetor
- Pesquise no banco de dados por pedaços mais semelhantes (usando métrica de distância cosseno)
- Envie as melhores correspondências + a pergunta para um modelo de idioma (usei Gemini)
- Increase – você obtém uma resposta clara e útil
E esse é o coração disso. Você não está substituindo o cérebro do modelo – apenas dando uma melhor memória.
Minha pilha: simples, poderosa, adequada para iniciantes
Aqui está o que eu usei:
- 🧠 Coere – Para transformar o conteúdo do livro e as perguntas em vetores (também conhecidos como incorporação)
- 📦 Pinecone – Para armazenar e pesquisar esses vetores tremendous eficientemente
- 💬 Gêmeos – Para gerar a resposta last de linguagem pure
Você não ter Para usá-los, mas essa combinação é adequada para iniciantes, bem documentada e toca bem juntos.
Passo a passo: construa seu próprio BOT AskMyBook
Okay, vamos realmente construir a coisa agora. Usei o Google Colab (porque a GPU gratuita e o compartilhamento fácil), mas isso deve funcionar em qualquer ambiente Python.
Etapa 1: Carregue e grite seu livro
Usei a biblioteca pymupdf para extrair texto.
!pip set up pymupdf
Agora, vamos extrair o texto:
import fitz # PyMuPDF
def extract_text_from_pdf(pdf_path):
doc = fitz.open(pdf_path)
textual content = ""
for web page in doc:
textual content += web page.get_text()
return textual content
book_path = 'enter the trail right here'
book_text = extract_text_from_pdf(book_path)
Agora, dividiremos o livro em pedaços, tornando -o mais digerível.
import re
def chunk_text(textual content, chunk_size=300, overlap=50):
phrases = re.findall(r'S+', textual content)
chunks = []
for i in vary(0, len(phrases), chunk_size - overlap):
chunk = ' '.be a part of(phrases[i:i + chunk_size])
chunks.append(chunk)
return chunks
chunks = chunk_text(book_text)
print(f"Complete Chunks: {len(chunks)}")
print("Pattern chunk:n", chunks[0])
Aqui, cada pedaço tem 300 palavras, com uma sobreposição de 50 palavras para a continuidade do contexto. Pense nisso como dar ao modelo um fluxo suave entre os parágrafos.
Etapa 2: Crie incorporação com coere
Incorporação = transformando texto em números que refletem o significado. Usaremos o modelo Incorpor-Inhish-V3.0 da Cohere para isso.
!pip set up cohere
import cohere
co = cohere.Consumer("YOUR-API-KEY") # Substitute along with your precise key
def get_embeddings(texts):
response = co.embed(
texts=texts,
mannequin="embed-english-v3.0",
input_type="search_document"
)
return response.embeddings
Etapa 3: armazenar pedaços em pinecone
Agora, armazenamos as incorporações em Pinecone – um banco de dados vetorial que nos ajuda a pesquisar pedaços semelhantes posteriormente.
!pip set up pinecone
import pinecone
pinecone = pinecone.Pinecone(api_key="YOUR-API-KEY")
index_name = "ask-my-book"
if index_name not in pinecone.list_indexes().names():
pinecone.create_index(
index_name,
spec={
"pod": {
"pod_type": "p1",
"replicas": 1,
"metric": "cosine",
"setting": "aws-us-east1"
}
},
dimension=1024
)
index = pinecone.Index(index_name)
Agora, o lote carrega os pedaços
import uuid
import time
batch_size = 96
for i in vary(0, len(chunks), batch_size):
batch_chunks = chunks[i:i+batch_size]
batch_embeds = get_embeddings(batch_chunks)
ids = [str(uuid.uuid4()) for _ in batch_chunks]
vectors = record(zip(ids, batch_embeds, [{"text": t} for t in batch_chunks]))
index.upsert(vectors=vectors)
time.sleep(60) # keep away from hitting price limits
BOOM! Seu livro agora está de maneira inteligente no formato vetorial.
Etapa 4: Faça perguntas + Obtenha respostas com Gêmeos
Vamos procurar pedaços relevantes usando sua consulta e depois passarmos a Gemini para gerar uma resposta.
Primeiro, obtenha a consulta incorporada:
def get_query_embedding(question):
response = co.embed(
texts=[query],
mannequin="embed-english-v3.0",
input_type="search_query"
)
return response.embeddings[0]
Agora, pesquise Pinecone:
def search_similar_chunks(question, top_k=5):
query_embedding = get_query_embedding(question)
end result = index.question(vector=query_embedding, top_k=top_k, include_metadata=True)
return [match['metadata']['text'] for match in end result['matches']]
Em seguida, conecte os pedaços superiores em Gêmeos:
import google.generativeai as genai
genai.configure(api_key="YOUR-GEMINI-API-KEY")
mannequin = genai.GenerativeModel("gemini-1.5-flash")
def generate_answer(question):
context_chunks = search_similar_chunks(question)
context = "nn".be a part of(context_chunks)
immediate = f"""
You might be an assistant bot skilled on the next ebook content material. Use solely the data supplied to reply the person's query.
E-book Context:
{context}
Query:
{question}
If the query isn't related to the context, reply with:
'I'm a bot skilled to reply questions primarily based on the ebook content material. This query is out of scope.'
"""
response = mannequin.generate_content(immediate)
return response.textual content
Experimente!
query = "What’s does the creator say in Module 1 of the ebook?"
print(generate_answer(query))
É isso-agora você tem um bot de Ask-My-E-book!
Você construiu um bot que:
- Entende seu livro
- Encontra a parte certa quando perguntado
- Fornece respostas significativas usando essa parte apenas
Não há mais desnatação sem fim. Apenas digite e pergunte.
O que vem a seguir? Subir o seu livro
O que construímos é um sistema básico, mas poderoso de perguntas e respostas. Pense nisso como o MVP (produto mínimo viável) do seu assistente de estudo pessoal.
Mas uma vez confortável, há muito mais que você pode acrescentar:
- Citações – Mostre de qual pedaço ou página da resposta veio, para que você possa verificar a fonte.
- Conversas com várias turnos-deixe o bot lembrar-se de perguntas anteriores e dar respostas mais inteligentes ao longo do tempo.
- Raciocínio de várias etapas-pensamentos em cadeia para responder a perguntas complexas.
- Memória personalizada – deixe seu bot manter fatos importantes que você destaca para perguntas futuras.
- Atualização da interface do usuário-conecte-o a um front-end de fluxo ou reação para uma experiência polida e amigável.
Com estes, seu bot vai de “Sensible Didk E-book” a “Ai Research Buddy”.
Se você já olhou para um livro, rezando para que apenas Recorrer de volta E diga o que importa – bem, agora pode.
Este foi o meu pequeno experimento em transformar PDFs chatos em conversas interativas. Espero que você encourage você a construir o seu próprio e talvez até personalizá -lo para amigos ou aulas.
Ficou preso em algum lugar? Deseja ajuda com a adição de uma interface do usuário ou citações a seguir? Deixe um comentário ou me pingue – sempre feliz em conversar.
