Upload 4 files

.dockerignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+*$py.class
+.env
+.venv
+venv/
+ENV/
+.git/
+.gitignore
+tests/
+.pytest_cache/
+*.pdf
+*.docx
+*.txt
+!requirements.txt
+README.md

Dockerfile

@@ -0,0 +1,32 @@
+# Usar uma imagem base leve de Python
+FROM python:3.9-slim
+
+# Definir variáveis de ambiente para o Python não gerar arquivos .pyc e não usar buffer para logs
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Definir o diretório de trabalho dentro do container
+WORKDIR /app
+
+# Instalar dependências do sistema necessárias para algumas bibliotecas Python
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copiar o arquivo de dependências
+COPY requirements.txt .
+
+# Instalar as dependências do Python
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copiar o restante do código do projeto
+COPY . .
+
+# Expor a porta que o Gradio usa por padrão
+EXPOSE 7860
+
+# Definir variáveis de ambiente para o Gradio (necessário para Hugging Face Spaces)
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+
+# Comando para rodar a aplicação
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,345 @@
+import gradio as gr
+from ibm_watson import NaturalLanguageUnderstandingV1
+from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
+from docx import Document
+from PyPDF2 import PdfReader
+import os
+from dotenv import load_dotenv
+import json
+import re
+import unicodedata
+import requests
+
+def normalizar_texto(texto):
+    """Remove acentos, caracteres especiais e converte para minúsculas."""
+    if not texto:
+        return ""
+    # Converte para minúsculas e remove espaços extras
+    texto = texto.lower().strip()
+    # Remove acentos
+    texto = "".join(c for c in unicodedata.normalize('NFD', texto) if unicodedata.category(c) != 'Mn')
+    # Remove pontuação básica para busca (mantém letras e números)
+    texto = re.sub(r'[^a-z0-9\s]', '', texto)
+    return texto
+
+# Carregar variáveis de ambiente
+load_dotenv()
+
+# Inicializar o Natural Language Understanding
+API_KEY = os.getenv('IBM_WATSON_API_KEY', 'SUA_CHAVE_API')
+SERVICE_URL = os.getenv('IBM_WATSON_URL', 'SUA_URL_SERVICO')
+PROJECT_ID = os.getenv('IBM_WATSONX_PROJECT_ID', 'SEU_PROJECT_ID')
+WATSONX_API_KEY = os.getenv('IBM_WATSONX_API_KEY', API_KEY) # Usa a chave específica ou a geral como fallback
+
+authenticator = IAMAuthenticator(API_KEY)
+nlu = NaturalLanguageUnderstandingV1(
+    version='2024-05-10',
+    authenticator=authenticator
+)
+nlu.set_service_url(SERVICE_URL)
+
+# Função para extrair texto de um documento
+def extrair_texto(arquivo):
+    if not arquivo:
+        return "Nenhum arquivo enviado."
+    
+    try:
+        # Se arquivo for um objeto gr.File, ele tem o atributo .name (caminho temporário)
+        nome_arquivo = arquivo.name if hasattr(arquivo, 'name') else arquivo
+        
+        if nome_arquivo.endswith('.pdf'):
+            reader = PdfReader(nome_arquivo)
+            texto = ''
+            for page in reader.pages:
+                page_text = page.extract_text()
+                if page_text:
+                    texto += page_text
+            return texto
+        elif nome_arquivo.endswith('.docx'):
+            doc = Document(nome_arquivo)
+            texto = ''
+            for para in doc.paragraphs:
+                texto += para.text + '\n'
+            return texto
+        elif nome_arquivo.endswith('.txt'):
+            with open(nome_arquivo, 'r', encoding='utf-8') as f:
+                return f.read()
+        else:
+            return "Formato de arquivo não suportado. Use PDF, DOCX ou TXT."
+    except Exception as e:
+        return f"Erro ao extrair texto: {str(e)}"
+
+# Função para processar o texto (Resumo, Tópicos, Classificação)
+def processar_texto(texto):
+    if not texto or len(texto.strip()) < 10:
+        return "Texto insuficiente para processamento.", "", ""
+    
+    try:
+        # Tenta o resumo automático (pode não estar disponível em todos os planos/regiões)
+        try:
+            resumo_res = nlu.analyze(
+                text=texto,
+                features={'summarization': {'limit': 1}}
+            ).get_result()
+            resumo = resumo_res.get('summarization', {}).get('text', 'Resumo não disponível.')
+        except Exception:
+            resumo = "Resumo automático não disponível no seu plano Watson NLU. Exibindo principais conceitos..."
+        
+        # Extração de tópicos-chave (keywords)
+        topicos_res = nlu.analyze(
+            text=texto,
+            features={'keywords': {'limit': 10}}
+        ).get_result()
+        topicos_lista = [k['text'] for k in topicos_res.get('keywords', [])]
+        topicos = ", ".join(topicos_lista[:5])
+        
+        # Se o resumo falhou, tentamos usar os tópicos para criar uma descrição simples
+        if "não disponível" in resumo:
+            resumo = f"O documento aborda temas como: {', '.join(topicos_lista[:3])}."
+        
+        # Classificação temática (categories)
+        classificacao_res = nlu.analyze(
+            text=texto,
+            features={'categories': {'limit': 5}}
+        ).get_result()
+        classificacao = ", ".join([c['label'] for c in classificacao_res.get('categories', [])])
+        
+        return resumo, topicos, classificacao
+    except Exception as e:
+        return f"Erro no processamento: {str(e)}", "", ""
+
+# Função para responder a perguntas sobre o documento (Q&A)
+def responder_pergunta(pergunta, texto):
+    if not pergunta or not texto:
+        return "Por favor, forneça uma pergunta e garanta que o documento foi analisado primeiro."
+    
+    try:
+        # 1. Extração de termos importantes da pergunta usando NLU (Keywords e Concepts)
+        termos_busca = []
+        try:
+            analise_pergunta = nlu.analyze(
+                text=pergunta,
+                features={'keywords': {}, 'concepts': {}}
+            ).get_result()
+            
+            for k in analise_pergunta.get('keywords', []):
+                termos_busca.append(normalizar_texto(k['text']))
+            for c in analise_pergunta.get('concepts', []):
+                termos_busca.append(normalizar_texto(c['text']))
+        except:
+            pass # Fallback para extração manual se o NLU falhar na pergunta curta
+        
+        # Se o Watson não retornar termos ou falhar, usamos split manual com normalização
+        if not termos_busca:
+            termos_busca = normalizar_texto(pergunta).split()
+
+        if not termos_busca:
+            # Última tentativa: se tudo falhar, usa a pergunta normalizada inteira
+            termos_busca = [normalizar_texto(pergunta)]
+
+        # 2. Processamento do texto do documento
+        # Normalizamos o texto completo para a busca
+        texto_normalizado = normalizar_texto(texto)
+        
+        # Dividimos o documento em blocos menores (parágrafos)
+        blocos_brutos = re.split(r'\n\s*\n', texto)
+        if len(blocos_brutos) < 2:
+            blocos_brutos = texto.split('\n')
+        
+        paragrafos_validos = []
+        for bloco in blocos_brutos:
+            limpo = bloco.strip()
+            if len(limpo) > 20: # Mantém blocos com conteúdo mínimo
+                paragrafos_validos.append({
+                    'original': limpo,
+                    'normalizado': normalizar_texto(limpo)
+                })
+        
+        # Se ainda houver poucos blocos, tentamos dividir por sentenças
+        if len(paragrafos_validos) < 3:
+            sentencas = re.split(r'\.\s+', texto)
+            paragrafos_validos = []
+            for s in sentencas:
+                limpo = s.strip()
+                if len(limpo) > 20:
+                    paragrafos_validos.append({
+                        'original': limpo,
+                        'normalizado': normalizar_texto(limpo)
+                    })
+
+        # 3. Cálculo de relevância (Ranking)
+        melhor_paragrafo = ""
+        maior_score = 0
+        
+        for item in paragrafos_validos:
+            p_norm = item['normalizado']
+            score = 0
+            
+            for termo in termos_busca:
+                if not termo: continue
+                # Se o termo exato (normalizado) está no parágrafo
+                if termo in p_norm:
+                    score += 1
+                    # Bônus por palavra inteira para evitar falso-positivos em substrings
+                    if re.search(rf'\b{re.escape(termo)}\b', p_norm):
+                        score += 2
+            
+            # Se o score for igual, preferimos o parágrafo mais curto (mais específico)
+            if score > maior_score:
+                maior_score = score
+                melhor_paragrafo = item['original']
+            elif score == maior_score and score > 0:
+                if len(item['original']) < len(melhor_paragrafo):
+                    melhor_paragrafo = item['original']
+        
+        # 4. Retorno do resultado
+        if melhor_paragrafo and maior_score > 0:
+            return f"Com base no documento, encontrei este trecho relevante:\n\n\"{melhor_paragrafo}\""
+        else:
+            return "Infelizmente não encontrei uma resposta direta no documento. Tente reformular sua pergunta com outros termos."
+
+    except Exception as e:
+        return f"Erro ao processar busca inteligente: {str(e)}"
+
+# --- Funções de Chat Inteligente (RAG com Watsonx AI) ---
+
+def obter_iam_token():
+    """Gera um token de acesso IAM usando a API Key do Watsonx."""
+    url = "https://iam.cloud.ibm.com/identity/token"
+    headers = {"Content-Type": "application/x-www-form-urlencoded"}
+    data = f"grant_type=urn:ibm:params:oauth:grant-type:apikey&apikey={WATSONX_API_KEY}"
+    
+    try:
+        response = requests.post(url, headers=headers, data=data)
+        if response.status_code == 200:
+            return response.json().get("access_token")
+        elif response.status_code == 400:
+            return f"Erro de Autenticação (400): A API Key fornecida é inválida ou não foi encontrada. Verifique seu arquivo .env."
+        else:
+            return f"Erro ao gerar token ({response.status_code}): {response.text}"
+    except Exception as e:
+        return f"Erro de conexão ao gerar token: {str(e)}"
+
+def chat_inteligente(pergunta, texto_documento):
+    """Realiza um chat inteligente (RAG) usando o modelo Llama-3 no Watsonx AI."""
+    if not pergunta or not texto_documento:
+        return "Por favor, analise um documento primeiro e digite uma pergunta."
+    
+    token = obter_iam_token()
+    if token.startswith("Erro"):
+        return token
+    
+    url = "https://us-south.ml.cloud.ibm.com/ml/v1/text/chat?version=2023-05-29"
+    
+    # Limitamos o texto do documento para não exceder o limite de tokens do modelo
+    contexto = texto_documento[:10000] # Aproximadamente 2500 tokens
+    
+    body = {
+        "messages": [
+            {
+                "role": "system",
+                "content": (
+                    "Você é um assistente de IA prestativo e honesto. "
+                    "Sua tarefa é responder perguntas baseando-se EXCLUSIVAMENTE no conteúdo do documento fornecido abaixo. "
+                    "Se a resposta não estiver no texto, diga que não encontrou a informação no documento. "
+                    "Responda sempre em português brasileiro e use formatação Markdown.\n\n"
+                    f"CONTEÚDO DO DOCUMENTO:\n{contexto}"
+                )
+            },
+            {
+                "role": "user",
+                "content": pergunta
+            }
+        ],
+        "project_id": PROJECT_ID,
+        "model_id": "meta-llama/llama-3-3-70b-instruct",
+        "frequency_penalty": 0,
+        "max_tokens": 2000,
+        "presence_penalty": 0,
+        "temperature": 0,
+        "top_p": 1
+    }
+    
+    headers = {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {token}"
+    }
+    
+    try:
+        response = requests.post(url, headers=headers, json=body)
+        if response.status_code != 200:
+            return f"Erro na API Watsonx: {response.text}"
+        
+        data = response.json()
+        return data['choices'][0]['message']['content']
+    except Exception as e:
+        return f"Erro no processamento do chat: {str(e)}"
+
+# --- Interface Gradio usando Blocks ---
+def criar_interface():
+    with gr.Blocks(title="Análise Inteligente de Documentos") as demo:
+        gr.Markdown("# 📑 Watsonx AI - Análise Inteligente de Documentos")
+        gr.Markdown("Extraia informações, resumos e faça perguntas sobre seus documentos PDF, DOCX ou TXT.")
+        
+        with gr.Tab("1. Extração e Análise"):
+            with gr.Row():
+                with gr.Column():
+                    arquivo_input = gr.File(label="Upload de Documento")
+                    botao_analisar = gr.Button("Analisar Documento", variant="primary")
+                
+                with gr.Column():
+                    texto_extraido = gr.Textbox(label="Texto Extraído", lines=10, interactive=False)
+            
+            with gr.Row():
+                resumo_output = gr.Textbox(label="Resumo Automático")
+                topicos_output = gr.Textbox(label="Tópicos-Chave")
+                classificacao_output = gr.Textbox(label="Classificação Temática")
+        
+        with gr.Tab("2. Localizador de Trechos (Busca Semântica)"):
+            gr.Markdown("### 🔍 Encontre trechos específicos no documento")
+            gr.Markdown("Esta ferramenta localiza os parágrafos mais relevantes que contêm os termos da sua pergunta.")
+            with gr.Row():
+                pergunta_input = gr.Textbox(label="O que você procura no texto?", placeholder="Ex: Metas de faturamento")
+                botao_perguntar = gr.Button("Localizar Trecho", variant="secondary")
+            
+            resposta_output = gr.Textbox(label="Trecho mais relevante encontrado", lines=10)
+
+        with gr.Tab("3. Chat Inteligente (RAG)"):
+            gr.Markdown("### 🤖 Pergunte à Inteligência Artificial")
+            gr.Markdown("O modelo Llama-3 analisará todo o documento para responder suas perguntas com raciocínio e síntese.")
+            with gr.Row():
+                chat_input = gr.Textbox(label="Sua Pergunta para a IA", placeholder="Ex: Qual o tema principal do documento?")
+                botao_chat = gr.Button("Gerar Resposta com IA", variant="primary")
+            
+            chat_output = gr.Markdown(label="Resposta da IA (Markdown)")
+
+        # Definição dos eventos
+        def executar_fluxo_analise(arquivo):
+            texto = extrair_texto(arquivo)
+            resumo, topicos, classificacao = processar_texto(texto)
+            return texto, resumo, topicos, classificacao
+
+        botao_analisar.click(
+            fn=executar_fluxo_analise,
+            inputs=[arquivo_input],
+            outputs=[texto_extraido, resumo_output, topicos_output, classificacao_output]
+        )
+        
+        botao_perguntar.click(
+            fn=responder_pergunta,
+            inputs=[pergunta_input, texto_extraido],
+            outputs=[resposta_output]
+        )
+
+        botao_chat.click(
+            fn=chat_inteligente,
+            inputs=[chat_input, texto_extraido],
+            outputs=[chat_output]
+        )
+        
+    return demo
+
+if __name__ == "__main__":
+    app = criar_interface()
+    app.launch()

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+ibm-watson
+python-docx
+PyPDF2
+python-dotenv
+pytest