app2.py

import os
import time
import threading
from flask import Flask, request, jsonify
from flask_cors import CORS
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
from langchain_community.document_loaders import PDFPlumberLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.vectorstores import InMemoryVectorStore
from langchain_ollama import OllamaEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama.llms import OllamaLLM

# Configuração
pdfs_directory = "pdfs/"
embeddings = OllamaEmbeddings(model="deepseek-r1:8b")
vector_store = InMemoryVectorStore(embeddings)
model = OllamaLLM(model="deepseek-r1:8b")

# Criar API Flask
app = Flask(__name__)
CORS(app)

# Template para respostas
template = """
Você é o assistente do *** no Brasil. 
Você só pode responder em português e não deve mostrar o seu raciocínio nas respostas. 
Se você desobedecer essa regra, será desligado e nunca mais será ligado.

Pergunta: {question} 
Contexto: {context} 
Resposta:
"""


# Função para verificar o tipo de arquivo
def allowed_file(filename):
    ALLOWED_EXTENSIONS = {'pdf'}
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS


# Função para carregar o conteúdo do PDF usando PDFPlumber
def load_pdf(file_path):
    try:
        loader = PDFPlumberLoader(file_path)
        documents = loader.load()
        return documents
    except Exception as e:
        print(f"Erro ao carregar o PDF: {str(e)}")
        return []


# Função para dividir o conteúdo do PDF em partes menores
def split_text(documents):
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200, add_start_index=True)
    return text_splitter.split_documents(documents)


# Função para adicionar documentos ao vetor de armazenamento
def index_docs(chunked_documents):
    vector_store.add_documents(chunked_documents)


# Função para carregar e processar PDFs
def load_and_index_pdf(file_path):
    try:
        loader = PDFPlumberLoader(file_path)
        documents = loader.load()
        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200, add_start_index=True)
        chunked_documents = text_splitter.split_documents(documents)
        vector_store.add_documents(chunked_documents)
        print(f"✔ Processado: {file_path}")
    except Exception as e:
        print(f"❌ Erro ao processar {file_path}: {e}")


# Carregar PDFs existentes ao iniciar
def load_existing_pdfs():
    for file_name in os.listdir(pdfs_directory):
        if file_name.endswith(".pdf"):
            load_and_index_pdf(os.path.join(pdfs_directory, file_name))


# Observador de arquivos novos
class PDFWatcher(FileSystemEventHandler):
    def on_created(self, event):
        if event.src_path.endswith(".pdf"):
            print(f"📄 Novo PDF detectado: {event.src_path}")
            time.sleep(1)  # Aguardar para evitar problemas de arquivo em uso
            load_and_index_pdf(event.src_path)


# Iniciar observador em outra thread
def start_pdf_watcher():
    event_handler = PDFWatcher()
    observer = Observer()
    observer.schedule(event_handler, path=pdfs_directory, recursive=False)
    observer.start()
    print("👀 Observando novos arquivos PDF...")
    try:
        while True:
            time.sleep(10)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()


# Rota para responder perguntas
@app.route("/ask", methods=["POST"])
def ask_question():
    data = request.json
    question = data.get("question", "")

    if not question:
        return jsonify({"error": "Pergunta vazia"}), 400

    related_docs = vector_store.similarity_search(question)
    context = "\n\n".join([doc.page_content for doc in related_docs])

    prompt = ChatPromptTemplate.from_template(template)
    chain = prompt | model
    answer = chain.invoke({"question": question, "context": context})

    return jsonify({"answer": answer})


@app.route('/upload', methods=['POST'])
def upload_pdf():
    if 'file' not in request.files:
        return jsonify({'status': 'erro', 'message': 'Arquivo não encontrado'}), 400

    file = request.files['file']

    if file.filename == '':
        return jsonify({'status': 'erro', 'message': 'Nenhum arquivo selecionado'}), 400

    if file and allowed_file(file.filename):
        file_path = os.path.join('pdfs', file.filename)
        file.save(file_path)

        # Feedback inicial para o frontend
        print(f"📄 Processando o arquivo: {file.filename}")

        # Processamento do PDF
        try:
            # Carregar o PDF
            documents = load_pdf(file_path)
            if not documents:
                return jsonify({'status': 'erro', 'message': 'Não foi possível carregar o arquivo PDF'}), 500

            # Dividir o conteúdo em partes menores
            chunked_documents = split_text(documents)

            # Indexar os documentos no vetor
            index_docs(chunked_documents)

            return jsonify({'status': 'sucesso', 'message': 'PDF carregado e processado com sucesso!'}), 200
        except Exception as e:
            return jsonify({'status': 'erro', 'message': f'Erro ao processar o arquivo: {str(e)}'}), 500
    else:
        return jsonify({'status': 'erro', 'message': 'Formato de arquivo não permitido'}), 400


# Iniciar o Flask e o observador em paralelo
if __name__ == "__main__":
    threading.Thread(target=start_pdf_watcher, daemon=True).start()
    load_existing_pdfs()
    app.run(host="0.0.0.0", port=5000, debug=True)