init: scripts diversos (crawlers, conversores, scrapers)

kb-processor/src/cli.py

@@ -0,0 +1,139 @@
+"""
+CLI - Interface de linha de comando
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+import os
+import sys
+import argparse
+from typing import List, Optional
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.prompt import Prompt, Confirm
+from rich import print as rprint
+from processors.web_processor import WebProcessor
+from processors.pdf_processor import PDFProcessor
+from processors.video_processor import VideoProcessor
+from processors.text_processor import TextProcessor
+
+console = Console()
+
+def get_processor(filepath: str):
+    """
+    Determina o processador adequado baseado no tipo de arquivo.
+    
+    Args:
+        filepath (str): Caminho do arquivo
+        
+    Returns:
+        BaseProcessor: Processador apropriado
+    """
+    _, ext = os.path.splitext(filepath)
+    ext = ext.lower()
+    
+    if ext in ['.pdf']:
+        return PDFProcessor(filepath)
+    elif ext in ['.txt', '.md', '.rst']:
+        return TextProcessor(filepath)
+    elif ext in ['.mp4', '.avi', '.mov', '.mkv']:
+        return VideoProcessor(filepath)
+    elif filepath.startswith(('http://', 'https://')):
+        return WebProcessor(filepath)
+    else:
+        raise ValueError(f"Tipo de arquivo não suportado: {ext}")
+
+def process_files(files: List[str], output_dir: str):
+    """
+    Processa uma lista de arquivos.
+    
+    Args:
+        files (List[str]): Lista de arquivos para processar
+        output_dir (str): Diretório de saída
+    """
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+    ) as progress:
+        for file in files:
+            try:
+                # Mostrar progresso
+                task = progress.add_task(f"A processar {os.path.basename(file)}...", total=None)
+                
+                # Criar processador
+                processor = get_processor(file)
+                
+                # Processar conteúdo
+                processor.process_content()
+                
+                # Gerar nome do arquivo de saída
+                basename = os.path.basename(file)
+                name, _ = os.path.splitext(basename)
+                timestamp = processor.metadata.get('data_original', '').replace('-', '')
+                output_file = os.path.join(output_dir, f"{name}_{timestamp}.md")
+                
+                # Salvar resultado
+                processor.save_markdown(output_file)
+                
+                # Mostrar sucesso
+                progress.remove_task(task)
+                rprint(f"[green]✓[/green] {basename} processado com sucesso!")
+                
+            except Exception as e:
+                progress.remove_task(task)
+                rprint(f"[red]✗[/red] Erro ao processar {file}: {str(e)}")
+
+def main():
+    """Função principal do CLI."""
+    parser = argparse.ArgumentParser(
+        description="Processador de Documentos - Descomplicar AI",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    
+    parser.add_argument(
+        'input',
+        nargs='+',
+        help='Arquivos ou URLs para processar'
+    )
+    
+    parser.add_argument(
+        '-o', '--output',
+        default='output',
+        help='Diretório de saída (padrão: output)'
+    )
+    
+    args = parser.parse_args()
+    
+    # Criar diretório de saída se não existir
+    os.makedirs(args.output, exist_ok=True)
+    
+    # Mostrar banner
+    console.print("""
+[bold blue]╔══════════════════════════════════════╗
+║     Processador de Documentos AI      ║
+║        Descomplicar - v1.0.0         ║
+╚══════════════════════════════════════╝[/bold blue]
+    """)
+    
+    # Confirmar processamento
+    files = args.input
+    rprint(f"\nArquivos a processar:")
+    for file in files:
+        rprint(f"  • {file}")
+    
+    if not Confirm.ask("\nContinuar com o processamento?"):
+        sys.exit(0)
+    
+    # Processar arquivos
+    process_files(files, args.output)
+    
+    rprint("\n[bold green]Processamento concluído![/bold green]")
+
+if __name__ == '__main__':
+    try:
+        main()
+    except KeyboardInterrupt:
+        rprint("\n[yellow]Processamento interrompido pelo usuário[/yellow]")
+    except Exception as e:
+        rprint(f"\n[red]Erro: {str(e)}[/red]")

kb-processor/src/correct_texts.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""
+correct_texts.py
+
+Author: Descomplicar® Crescimento Digital
+Link: https://descomplicar.pt
+Copyright: 2025 Descomplicar®
+"""
+
+import os
+import shutil
+from pathlib import Path
+from processors.text_corrector import TextCorrector
+import concurrent.futures
+from tqdm import tqdm
+
+def format_title(filename: str) -> str:
+    """Formata o nome do arquivo para um título legível."""
+    # Remove extensão e data no formato _YYYYMMDD_HHMMSS
+    title = filename.replace('.txt', '').split('_2025')[0]
+    # Substitui underscores por espaços
+    title = title.replace('_', ' ')
+    # Capitaliza palavras
+    title = ' '.join(word.capitalize() for word in title.split())
+    return title
+
+def process_file(corrector, file_path, output_dir, processed_dir):
+    """Processa um único arquivo."""
+    try:
+        # Ler o texto
+        texto = file_path.read_text(encoding="utf-8")
+        
+        # Criar título a partir do nome do arquivo
+        titulo = format_title(file_path.name)
+        
+        # Adicionar título ao texto
+        texto_com_titulo = f"# {titulo}\n\n{texto}"
+        
+        # Corrigir o texto
+        texto_corrigido = corrector.correct_text(texto_com_titulo)
+        
+        # Salvar resultado
+        output_file = output_dir / f"corrigido_{file_path.name}"
+        output_file.write_text(texto_corrigido, encoding="utf-8")
+        
+        # Mover original para processados
+        target_path = processed_dir / file_path.name
+        shutil.move(str(file_path), str(target_path))
+        
+        return True, file_path.name
+        
+    except Exception as e:
+        return False, f"Erro ao processar {file_path.name}: {str(e)}"
+
+def main():
+    # Definir diretórios
+    base_dir = Path(__file__).parent.parent
+    input_dir = base_dir / "input"
+    output_dir = base_dir / "corrected"
+    processed_dir = input_dir / "originais_processados"
+    
+    # Criar diretórios necessários
+    output_dir.mkdir(exist_ok=True)
+    processed_dir.mkdir(exist_ok=True)
+    
+    # Verificar arquivos já processados
+    processed_files = {f.stem.replace('corrigido_', '') for f in output_dir.glob('corrigido_*.txt')}
+    
+    # Mover arquivos já processados
+    for input_file in input_dir.glob("*.txt"):
+        if input_file.stem in processed_files:
+            target_path = processed_dir / input_file.name
+            shutil.move(str(input_file), str(target_path))
+            print(f"→ Movido para processados: {input_file.name}")
+            continue
+    
+    # Criar instância do corretor
+    corrector = TextCorrector()
+    
+    # Listar arquivos para processar
+    files = list(input_dir.glob("*.txt"))
+    if not files:
+        print("Nenhum arquivo .txt encontrado na pasta input")
+        return
+    
+    print(f"Processando {len(files)} arquivos em paralelo...")
+    
+    # Processar arquivos em paralelo
+    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+        # Criar lista de futures
+        futures = [
+            executor.submit(process_file, corrector, f, output_dir, processed_dir)
+            for f in files
+        ]
+        
+        # Processar resultados com barra de progresso
+        for future in tqdm(concurrent.futures.as_completed(futures), total=len(files)):
+            success, result = future.result()
+            if success:
+                print(f"✓ {result}")
+            else:
+                print(f"✗ {result}")
+
+if __name__ == "__main__":
+    main()

kb-processor/src/corrigir_texto.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""
+corrigir_texto.py
+
+Author: Descomplicar® Crescimento Digital
+Link: https://descomplicar.pt
+Copyright: 2025 Descomplicar®
+"""
+
+from processors.text_corrector import TextCorrector
+
+def main():
+    # Cria uma instância do corretor
+    corrector = TextCorrector()
+    
+    # Solicita o texto ao usuário
+    print("Digite ou cole o texto a ser corrigido (Ctrl+D para terminar):")
+    try:
+        texto = ""
+        while True:
+            linha = input()
+            texto += linha + "\n"
+    except EOFError:
+        pass
+    
+    # Corrige o texto
+    texto_corrigido = corrector.correct_text(texto)
+    
+    # Mostra o resultado
+    print("\nTexto Corrigido:")
+    print("="*50)
+    print(texto_corrigido)
+
+if __name__ == "__main__":
+    main()

kb-processor/src/enrichment/faq_generator.py

@@ -0,0 +1,85 @@
+"""
+FAQ Generator - Módulo para geração de FAQs
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+from openai import OpenAI
+from typing import List, Dict
+
+class FAQGenerator:
+    """Gerador de FAQs usando OpenAI."""
+    
+    def __init__(self):
+        """Inicializa o gerador de FAQs."""
+        self.client = OpenAI(
+            api_key="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"
+        )
+    
+    def generate_faqs(self, content: str, num_faqs: int = 3) -> List[Dict[str, str]]:
+        """
+        Gera FAQs a partir do conteúdo fornecido.
+        
+        Args:
+            content (str): Texto para gerar FAQs
+            num_faqs (int): Número de FAQs a gerar
+            
+        Returns:
+            List[Dict[str, str]]: Lista de FAQs geradas
+        """
+        if not content.strip():
+            return []
+            
+        # Limitar tamanho do conteúdo para evitar tokens excessivos
+        max_chars = 2000
+        if len(content) > max_chars:
+            content = content[:max_chars] + "..."
+            
+        try:
+            # Criar prompt específico para plugins e funcionalidades
+            prompt = f"""
+            Analise o seguinte texto e gere exatamente {num_faqs} perguntas e respostas relevantes em português de Portugal.
+            
+            Foque em:
+            1. Funcionalidades principais
+            2. Requisitos e compatibilidade
+            3. Resolução de problemas
+            
+            Mantenha termos técnicos em inglês quando apropriado.
+            Use formato:
+            P: [pergunta]
+            R: [resposta curta e direta]
+            
+            Texto:
+            {content}
+            """
+            
+            response = self.client.chat.completions.create(
+                model="gpt-4",
+                messages=[
+                    {"role": "system", "content": "És um especialista em WordPress. Gera FAQs técnicas e diretas em português de Portugal."},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=500  # Limitar tokens na resposta
+            )
+            
+            # Processar resposta
+            raw_faqs = response.choices[0].message.content.strip().split('\n\n')
+            faqs = []
+            
+            for raw_faq in raw_faqs[:num_faqs]:  # Limitar número de FAQs
+                if raw_faq.startswith('P:'):
+                    parts = raw_faq.split('\nR:')
+                    if len(parts) == 2:
+                        question = parts[0].replace('P:', '').strip()
+                        answer = parts[1].strip()
+                        faqs.append({
+                            'question': question,
+                            'answer': answer
+                        })
+            
+            return faqs
+            
+        except Exception as e:
+            print(f"Erro ao gerar FAQs: {str(e)}")
+            return []

kb-processor/src/main.py

@@ -0,0 +1,102 @@
+"""
+Main - Script principal para processamento de documentos
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+import os
+import argparse
+from urllib.parse import urlparse
+from datetime import datetime
+from pathlib import Path
+from processors.pdf_processor import PDFProcessor
+from processors.txt_processor import TXTProcessor
+from processors.web_processor import WebProcessor
+from enrichment.faq_generator import FAQGenerator
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def is_url(string: str) -> bool:
+    """
+    Verifica se uma string é uma URL válida.
+    
+    Args:
+        string (str): String a verificar
+        
+    Returns:
+        bool: True se for URL, False caso contrário
+    """
+    try:
+        result = urlparse(string)
+        return all([result.scheme, result.netloc])
+    except ValueError:
+        return False
+
+def process_document(input_path: str, output_file: str = None) -> None:
+    """
+    Processa um documento e gera o output formatado.
+    
+    Args:
+        input_path (str): Caminho do ficheiro ou URL de entrada
+        output_file (str): Caminho do ficheiro de saída (opcional)
+    """
+    # Verificar se é URL ou ficheiro local
+    if is_url(input_path):
+        processor = WebProcessor(input_path)
+    else:
+        # Determinar tipo de ficheiro
+        file_ext = os.path.splitext(input_path)[1].lower()
+        
+        # Selecionar processador apropriado
+        if file_ext == '.pdf':
+            processor = PDFProcessor(input_path)
+        elif file_ext in ['.txt', '.md']:
+            processor = TXTProcessor(input_path)
+        else:
+            raise ValueError(f"Tipo de ficheiro não suportado: {file_ext}")
+    
+    try:
+        # Processar conteúdo
+        processor.process_content()
+        
+        # Gerar FAQs para cada capítulo
+        faq_gen = FAQGenerator()
+        for chapter in processor.chapters:
+            faqs = faq_gen.generate_faqs(chapter['content'])
+            chapter['faqs'] = faqs
+        
+        # Definir ficheiro de saída se não especificado
+        if not output_file:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            if is_url(input_path):
+                base_name = urlparse(input_path).netloc.replace('.', '_')
+            else:
+                base_name = os.path.splitext(os.path.basename(input_path))[0]
+            
+            # Usar caminho absoluto
+            output_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "output")
+            output_file = os.path.join(output_dir, f"{base_name}_{timestamp}.md")
+        
+        # Criar diretório de saída se não existir
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+        
+        # Salvar resultado
+        processor.save_markdown(output_file)
+        print(f"Documento processado com sucesso: {output_file}")
+        
+    except Exception as e:
+        print(f"Erro ao processar documento: {str(e)}")
+        raise
+
+def main():
+    """Função principal."""
+    parser = argparse.ArgumentParser(description='Processador de documentos com geração de FAQs')
+    parser.add_argument('input', help='Ficheiro de entrada ou URL')
+    parser.add_argument('-o', '--output', help='Ficheiro de saída (opcional)')
+    
+    args = parser.parse_args()
+    process_document(args.input, args.output)
+
+if __name__ == "__main__":
+    main()

kb-processor/src/mover_processados.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""
+mover_processados.py
+
+Author: Descomplicar® Crescimento Digital
+Link: https://descomplicar.pt
+Copyright: 2025 Descomplicar®
+"""
+
+import os
+import shutil
+from pathlib import Path
+
+def main():
+    # Definir diretórios
+    base_dir = Path(__file__).parent.parent
+    input_dir = base_dir / "input"
+    output_dir = base_dir / "corrected"
+    processed_dir = input_dir / "originais_processados"
+    
+    # Criar diretório de processados
+    processed_dir.mkdir(exist_ok=True)
+    
+    # Obter lista de arquivos já corrigidos
+    corrected_files = {f.stem.replace('corrigido_', '') for f in output_dir.glob('corrigido_*.txt')}
+    
+    # Mover arquivos originais que já foram processados
+    moved = 0
+    for input_file in input_dir.glob("*.txt"):
+        if input_file.stem in corrected_files:
+            target_path = processed_dir / input_file.name
+            shutil.move(str(input_file), str(target_path))
+            print(f"→ Movido: {input_file.name}")
+            moved += 1
+    
+    print(f"\nTotal de {moved} arquivos movidos para {processed_dir}")
+
+if __name__ == "__main__":
+    main()

kb-processor/src/process_docs.py

@@ -0,0 +1,179 @@
+"""
+Script para processar documentos (PDF e TXT) e carregar no banco de dados
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+import os
+from pathlib import Path
+from processors.pdf_processor import PDFProcessor
+from processors.txt_processor import TXTProcessor
+from processors.db_processor import DBProcessor
+from processors.embedding_processor import EmbeddingProcessor
+from dotenv import load_dotenv
+import json
+from datetime import datetime
+
+def update_changelog(new_files: list, modified_files: list = None):
+    """Atualiza o CHANGELOG.md"""
+    changelog_path = Path(__file__).parent.parent / 'CHANGELOG.md'
+    
+    # Criar entrada para hoje
+    today = datetime.now().strftime('%d-%m-%Y')
+    entry = f"\n[1.0.0] - {today}\n"
+    
+    if new_files:
+        entry += "\nAdicionado\n"
+        for file in new_files:
+            entry += f"- {file}\n"
+    
+    if modified_files:
+        entry += "\nAlterado\n"
+        for file in modified_files:
+            entry += f"- {file}\n"
+    
+    # Adicionar ao início do arquivo
+    if changelog_path.exists():
+        content = changelog_path.read_text()
+    else:
+        content = "# Changelog\n\nTodas as alterações notáveis neste projeto serão documentadas neste arquivo.\n"
+    
+    content = content.split('\n\n', 1)[0] + '\n' + entry + '\n' + content.split('\n\n', 1)[1]
+    changelog_path.write_text(content)
+
+def update_readme(processed_files: list):
+    """Atualiza o README.md com informações dos documentos processados"""
+    readme_path = Path(__file__).parent.parent / 'README.md'
+    
+    content = """# SuperBot Knowledge Base
+
+Base de Conhecimento para o SuperBot da Descomplicar.
+
+## Documentos Processados
+
+| Documento | Tipo | Data | Tags |
+|-----------|------|------|------|
+"""
+    
+    for doc in processed_files:
+        tags = ', '.join(doc['tags']) if isinstance(doc['tags'], list) else doc['tags']
+        content += f"| {doc.get('título', 'Sem título')} | {doc.get('tipo_documento', 'N/A')} | {doc.get('data_original', 'N/A')} | {tags} |\n"
+    
+    content += """
+## Estrutura do Projeto
+
+- `input/`: Diretório com os documentos originais (PDF e TXT)
+- `output/`: Diretório com os documentos processados em markdown
+- `src/`: Código fonte
+  - `processors/`: Módulos de processamento
+    - `pdf_processor.py`: Processamento de PDFs
+    - `txt_processor.py`: Processamento de TXTs
+    - `db_processor.py`: Integração com banco de dados
+    - `embedding_processor.py`: Geração de embeddings
+"""
+    
+    readme_path.write_text(content)
+
+def process_file(file_path: str, output_dir: Path, db: DBProcessor, embedding: EmbeddingProcessor):
+    """Processa um arquivo individual."""
+    print(f"\nA processar ficheiro: {file_path}")
+    
+    # Criar diretório de saída específico
+    doc_output_dir = output_dir / Path(file_path).stem
+    doc_output_dir.mkdir(exist_ok=True)
+    
+    # Escolher processador baseado na extensão
+    ext = Path(file_path).suffix.lower()
+    if ext == '.pdf':
+        processor = PDFProcessor(file_path)
+    elif ext == '.txt':
+        processor = TXTProcessor(file_path)
+    else:
+        raise ValueError(f"Tipo de ficheiro não suportado: {ext}")
+    
+    # Processar documento
+    processor.process_content()
+    
+    # Salvar em markdown
+    output_file = doc_output_dir / 'conteudo.md'
+    processor.save_markdown(str(output_file))
+    
+    # Salvar metadados
+    metadata_file = doc_output_dir / 'metadata.json'
+    with open(metadata_file, 'w', encoding='utf-8') as f:
+        json.dump(processor.metadata, f, ensure_ascii=False, indent=2)
+    
+    # Salvar no banco de dados
+    print("A salvar no banco de dados...")
+    document_id = db.save_document(
+        title=processor.metadata.get('título', ''),
+        content=processor.content,
+        metadata=processor.metadata,
+        file_path=file_path
+    )
+    print(f"Documento salvo com ID: {document_id}")
+    
+    # Gerar embeddings
+    print("A gerar embeddings...")
+    embedding.update_document_embeddings(document_id)
+    print("Embeddings gerados com sucesso")
+    
+    return processor.metadata
+
+def main():
+    """Função principal."""
+    # Carregar variáveis de ambiente
+    load_dotenv()
+    
+    # Configurar diretórios
+    project_root = Path(__file__).parent.parent
+    input_dir = project_root / 'input'
+    output_dir = project_root / 'output'
+    
+    # Criar diretórios se não existirem
+    input_dir.mkdir(exist_ok=True)
+    output_dir.mkdir(exist_ok=True)
+    
+    # Inicializar processadores
+    db = DBProcessor()
+    embedding = EmbeddingProcessor()
+    
+    try:
+        # Inicializar schema do banco de dados
+        print("A inicializar schema do banco de dados...")
+        db.init_schema()
+        
+        # Lista para armazenar informações dos documentos processados
+        processed_docs = []
+        new_files = []
+        
+        # Processar cada arquivo no diretório de entrada
+        for filename in os.listdir(input_dir):
+            if filename.endswith(('.pdf', '.txt')):
+                input_file = os.path.join(input_dir, filename)
+                
+                try:
+                    # Processar arquivo
+                    metadata = process_file(input_file, output_dir, db, embedding)
+                    
+                    # Adicionar à lista de documentos processados
+                    processed_docs.append(metadata)
+                    new_files.append(filename)
+                    
+                    print(f"\nResultado guardado em: {output_dir / Path(filename).stem}")
+                    
+                except Exception as e:
+                    print(f"Erro ao processar {filename}: {str(e)}")
+                    continue
+        
+        # Atualizar documentação
+        if processed_docs:
+            update_readme(processed_docs)
+            update_changelog(new_files)
+            print("\nDocumentação atualizada com sucesso!")
+        
+    except Exception as e:
+        print(f"Erro: {str(e)}")
+
+if __name__ == "__main__":
+    main()

kb-processor/src/process_pdf.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Script para processar PDFs e carregar no banco de dados
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+import os
+from pathlib import Path
+from processors.pdf_processor import PDFProcessor
+from processors.db_processor import DBProcessor
+from processors.embedding_processor import EmbeddingProcessor
+from dotenv import load_dotenv
+import json
+from datetime import datetime
+
+def update_changelog(new_files: list, modified_files: list = None):
+    """Atualiza o CHANGELOG.md"""
+    changelog_path = Path(__file__).parent.parent / 'CHANGELOG.md'
+    
+    # Criar entrada para hoje
+    today = datetime.now().strftime('%d-%m-%Y')
+    entry = f"\n[1.0.0] - {today}\n"
+    
+    if new_files:
+        entry += "\nAdicionado\n"
+        for file in new_files:
+            entry += f"- {file}\n"
+    
+    if modified_files:
+        entry += "\nAlterado\n"
+        for file in modified_files:
+            entry += f"- {file}\n"
+    
+    # Adicionar ao início do arquivo
+    if changelog_path.exists():
+        content = changelog_path.read_text()
+    else:
+        content = "# Changelog\n\nTodas as alterações notáveis neste projeto serão documentadas neste arquivo.\n"
+    
+    content = content.split('\n\n', 1)[0] + '\n' + entry + '\n' + content.split('\n\n', 1)[1]
+    changelog_path.write_text(content)
+
+def update_readme(processed_files: list):
+    """Atualiza o README.md com informações dos documentos processados"""
+    readme_path = Path(__file__).parent.parent / 'README.md'
+    
+    content = """# SuperBot Knowledge Base
+
+Base de Conhecimento para o SuperBot da Descomplicar.
+
+## Documentos Processados
+
+| Documento | Tipo | Data | Tags |
+|-----------|------|------|------|
+"""
+    
+    for doc in processed_files:
+        tags = ', '.join(doc['tags']) if isinstance(doc['tags'], list) else doc['tags']
+        content += f"| {doc.get('título', 'Sem título')} | {doc.get('tipo_documento', 'N/A')} | {doc.get('data_original', 'N/A')} | {tags} |\n"
+    
+    content += """
+## Estrutura do Projeto
+
+- `input/`: Diretório com os PDFs originais
+- `output/`: Diretório com os documentos processados em markdown
+- `src/`: Código fonte
+  - `processors/`: Módulos de processamento
+    - `pdf_processor.py`: Processamento de PDFs
+    - `db_processor.py`: Integração com banco de dados
+    - `embedding_processor.py`: Geração de embeddings
+"""
+    
+    readme_path.write_text(content)
+
+def main():
+    """Função principal."""
+    # Carregar variáveis de ambiente
+    load_dotenv()
+    
+    # Configurar diretórios
+    project_root = Path(__file__).parent.parent
+    input_dir = project_root / 'input'
+    output_dir = project_root / 'output'
+    
+    # Criar diretórios se não existirem
+    input_dir.mkdir(exist_ok=True)
+    output_dir.mkdir(exist_ok=True)
+    
+    # Inicializar processadores
+    db = DBProcessor()
+    embedding = EmbeddingProcessor()
+    
+    try:
+        # Inicializar schema do banco de dados
+        print("A inicializar schema do banco de dados...")
+        db.init_schema()
+        
+        # Lista para armazenar informações dos documentos processados
+        processed_docs = []
+        new_files = []
+        
+        # Processar cada PDF no diretório de entrada
+        for filename in os.listdir(input_dir):
+            if filename.endswith('.pdf'):
+                input_file = os.path.join(input_dir, filename)
+                print(f"\nA processar ficheiro: {input_file}")
+                
+                # Criar diretório de saída específico
+                doc_output_dir = output_dir / filename.replace('.pdf', '')
+                doc_output_dir.mkdir(exist_ok=True)
+                
+                # Processar PDF
+                processor = PDFProcessor(input_file)
+                processor.process_content()
+                
+                # Salvar em markdown
+                output_file = doc_output_dir / 'conteudo.md'
+                processor.save_markdown(str(output_file))
+                
+                # Salvar metadados
+                metadata_file = doc_output_dir / 'metadata.json'
+                with open(metadata_file, 'w', encoding='utf-8') as f:
+                    json.dump(processor.metadata, f, ensure_ascii=False, indent=2)
+                
+                # Salvar no banco de dados
+                print("A salvar no banco de dados...")
+                document_id = db.save_document(
+                    title=processor.metadata.get('título', ''),
+                    content=processor.content,
+                    metadata=processor.metadata,
+                    file_path=input_file
+                )
+                print(f"Documento salvo com ID: {document_id}")
+                
+                # Gerar embeddings
+                print("A gerar embeddings...")
+                embedding.update_document_embeddings(document_id)
+                print("Embeddings gerados com sucesso")
+                
+                # Adicionar à lista de documentos processados
+                processed_docs.append(processor.metadata)
+                new_files.append(filename)
+                
+                print(f"\nResultado guardado em: {doc_output_dir}")
+        
+        # Atualizar documentação
+        if processed_docs:
+            update_readme(processed_docs)
+            update_changelog(new_files)
+            print("\nDocumentação atualizada com sucesso!")
+        
+    except Exception as e:
+        print(f"Erro: {str(e)}")
+
+if __name__ == "__main__":
+    main()

kb-processor/src/process_transcripts.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""
+process_transcripts.py
+
+Author: Descomplicar® Crescimento Digital
+Link: https://descomplicar.pt
+Copyright: 2025 Descomplicar®
+"""
+
+import shutil
+from pathlib import Path
+from processors.text_corrector import TextCorrector
+import concurrent.futures
+from tqdm import tqdm
+
+def copy_structure(src_dir, dest_dir):
+    """Copia a estrutura de pastas mantendo a hierarquia"""
+    src_path = Path(src_dir)
+    dest_path = Path(dest_dir)
+    
+    # Copia cada pasta e ficheiro
+    for src_file in src_path.rglob('*.txt'):
+        # Calcula o caminho relativo
+        rel_path = src_file.relative_to(src_path)
+        # Cria o caminho de destino
+        dest_file = dest_path / rel_path
+        # Garante que a pasta de destino existe
+        dest_file.parent.mkdir(parents=True, exist_ok=True)
+        # Copia o ficheiro
+        shutil.copy2(src_file, dest_file)
+        print(f"Copiado: {rel_path}")
+
+def process_file(corrector, src_file, input_dir, output_dir):
+    """Processa um único ficheiro"""
+    try:
+        # Calcula caminhos relativos
+        rel_path = src_file.relative_to(input_dir)
+        output_file = output_dir / rel_path.parent / f"corrigido_{rel_path.name}"
+        
+        # Garante que a pasta de destino existe
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Lê e corrige o texto
+        texto = src_file.read_text(encoding="utf-8")
+        texto_corrigido = corrector.correct_text(texto)
+        
+        # Salva o resultado
+        output_file.write_text(texto_corrigido, encoding="utf-8")
+        
+        return True, str(rel_path)
+        
+    except Exception as e:
+        return False, f"Erro ao processar {rel_path}: {str(e)}"
+
+def main():
+    # Definir diretórios
+    src_dir = Path("/home/ealmeida/Scripts/youtube-transcript/transcricoes")
+    input_dir = Path("/home/ealmeida/Scripts/SuperBot-KB/input")
+    output_dir = Path("/home/ealmeida/Scripts/SuperBot-KB/corrected")
+    
+    # Copiar estrutura para input
+    print("\nCopiando ficheiros para input...")
+    copy_structure(src_dir, input_dir)
+    
+    # Listar todos os ficheiros .txt no input
+    input_files = list(input_dir.rglob("*.txt"))
+    if not input_files:
+        print("Nenhum ficheiro .txt encontrado para processar")
+        return
+    
+    print(f"\nProcessando {len(input_files)} ficheiros...")
+    
+    # Criar instância do corretor
+    corrector = TextCorrector()
+    
+    # Processar ficheiros em paralelo
+    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+        # Criar lista de futures
+        futures = [
+            executor.submit(process_file, corrector, f, input_dir, output_dir)
+            for f in input_files
+        ]
+        
+        # Processar resultados com barra de progresso
+        for future in tqdm(concurrent.futures.as_completed(futures), total=len(input_files)):
+            success, result = future.result()
+            if success:
+                print(f"✓ {result}")
+            else:
+                print(f"✗ {result}")
+    
+    print("\nProcessamento concluído!")
+
+if __name__ == "__main__":
+    main()

kb-processor/src/processors/ai_chat_processor.py

@@ -0,0 +1,150 @@
+"""
+ai_chat_processor.py
+
+Author: Descomplicar® Crescimento Digital
+Link: https://descomplicar.pt
+Copyright: 2025 Descomplicar®
+"""
+
+"""
+Processador para chatbot AI integrado com Chatwoot.
+"""
+import json
+import requests
+from typing import Dict, List, Optional
+from .db_processor import DBProcessor
+from .embedding_processor import EmbeddingProcessor
+
+class AIChatProcessor:
+    def __init__(self, chatwoot_api_key: str, chatwoot_account_id: str, chatwoot_base_url: str):
+        """
+        Inicializa o processador de chat AI.
+        
+        Args:
+            chatwoot_api_key: Chave API do Chatwoot
+            chatwoot_account_id: ID da conta Chatwoot
+            chatwoot_base_url: URL base da API Chatwoot (ex: https://app.chatwoot.com)
+        """
+        self.chatwoot_api_key = chatwoot_api_key
+        self.chatwoot_account_id = chatwoot_account_id
+        self.chatwoot_base_url = chatwoot_base_url.rstrip('/')
+        
+        # Inicializa processadores
+        self.db = DBProcessor()
+        self.embedding_processor = EmbeddingProcessor()
+        
+        # Headers para API Chatwoot
+        self.headers = {
+            'api_access_token': chatwoot_api_key,
+            'Content-Type': 'application/json'
+        }
+        
+    def _search_knowledge_base(self, query: str, limit: int = 3) -> List[Dict]:
+        """
+        Pesquisa na base de conhecimento usando embeddings.
+        
+        Args:
+            query: Pergunta do usuário
+            limit: Número máximo de resultados
+            
+        Returns:
+            Lista de resultados mais relevantes
+        """
+        # Gera embedding da pergunta
+        query_embedding = self.embedding_processor.generate_embedding(query)
+        
+        # Busca resultados similares
+        results = self.db.search_similar_chunks(
+            query_embedding,
+            limit=limit
+        )
+        
+        return results
+        
+    def _format_response(self, query: str, results: List[Dict]) -> str:
+        """
+        Formata resposta com base nos resultados da pesquisa.
+        
+        Args:
+            query: Pergunta original
+            results: Resultados da pesquisa
+            
+        Returns:
+            Resposta formatada
+        """
+        if not results:
+            return "Desculpe, não encontrei informações relevantes sobre isso na base de conhecimento."
+            
+        # Formata resposta
+        response = "Com base na nossa base de conhecimento:\n\n"
+        
+        for i, result in enumerate(results, 1):
+            relevance = result.get('relevance', 0) * 100
+            content = result.get('content', '').strip()
+            source = result.get('source', 'Desconhecida')
+            
+            response += f"{i}. Relevância: {relevance:.1f}%\n"
+            response += f"Fonte: {source}\n"
+            response += f"Conteúdo: {content}\n\n"
+            
+        return response
+        
+    def process_message(self, conversation_id: str, message: str) -> None:
+        """
+        Processa mensagem recebida e envia resposta via Chatwoot.
+        
+        Args:
+            conversation_id: ID da conversa no Chatwoot
+            message: Mensagem recebida
+        """
+        # Pesquisa na base de conhecimento
+        results = self._search_knowledge_base(message)
+        
+        # Formata resposta
+        response = self._format_response(message, results)
+        
+        # Envia resposta via API Chatwoot
+        endpoint = f"{self.chatwoot_base_url}/api/v1/accounts/{self.chatwoot_account_id}/conversations/{conversation_id}/messages"
+        
+        payload = {
+            'content': response,
+            'message_type': 'outgoing',
+            'private': False
+        }
+        
+        try:
+            r = requests.post(
+                endpoint,
+                headers=self.headers,
+                data=json.dumps(payload)
+            )
+            r.raise_for_status()
+            
+        except requests.exceptions.RequestException as e:
+            print(f"Erro ao enviar mensagem para Chatwoot: {e}")
+            
+    def handle_webhook(self, data: Dict) -> Optional[str]:
+        """
+        Processa webhook recebido do Chatwoot.
+        
+        Args:
+            data: Dados do webhook
+            
+        Returns:
+            ID da conversa se mensagem deve ser processada
+        """
+        # Verifica se é mensagem de entrada
+        if data.get('message_type') != 'incoming':
+            return None
+            
+        # Extrai dados relevantes
+        conversation_id = data.get('conversation', {}).get('id')
+        message = data.get('content')
+        
+        if not all([conversation_id, message]):
+            return None
+            
+        # Processa mensagem
+        self.process_message(conversation_id, message)
+        
+        return conversation_id

kb-processor/src/processors/base_processor.py

@@ -0,0 +1,130 @@
+"""
+Base Processor - Processador base para documentos
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+import os
+import json
+from typing import Dict, List, Optional
+from datetime import datetime
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+class BaseProcessor(ABC):
+    """Classe base para processamento de documentos."""
+    
+    def __init__(self, input_file: str):
+        """
+        Inicializa o processador base.
+        
+        Args:
+            input_file (str): Caminho para o ficheiro de entrada
+        """
+        self.input_file = input_file
+        self.content = ""
+        self.metadata = {
+            "título": "",
+            "autor_original": "",
+            "data_original": "",
+            "tipo_documento": "",
+            "fonte": "",
+            "licença": "",
+            "última_atualização": datetime.now().strftime("%d-%m-%Y"),
+            "categoria_principal": "",
+            "tags": [],
+            "nível_técnico": "",
+            "idioma_original": "",
+            "tradutor": "Descomplicar AI",
+            "revisão": "1.0"
+        }
+        self.chapters = []
+
+    @abstractmethod
+    def read_content(self) -> str:
+        """Lê o conteúdo do ficheiro."""
+        pass
+
+    @abstractmethod
+    def process_content(self) -> None:
+        """Processa o conteúdo do ficheiro."""
+        pass
+
+    def extract_metadata(self) -> Dict:
+        """Extrai metadados do documento."""
+        return self.metadata
+
+    def structure_content(self) -> List[Dict]:
+        """Estrutura o conteúdo em capítulos."""
+        chapters = []
+        current_chapter = {"title": "", "content": "", "faqs": []}
+        
+        lines = self.content.split("\n")
+        for line in lines:
+            if line.strip().startswith("#"):
+                if current_chapter["title"]:
+                    chapters.append(current_chapter.copy())
+                current_chapter = {
+                    "title": line.strip("# "),
+                    "content": "",
+                    "faqs": []
+                }
+            else:
+                current_chapter["content"] += line + "\n"
+        
+        if current_chapter["title"]:
+            chapters.append(current_chapter)
+        
+        self.chapters = chapters
+        return chapters
+
+    def generate_markdown(self) -> str:
+        """Gera o documento final em Markdown."""
+        md_content = []
+        
+        # Metadados
+        md_content.append("---")
+        for key, value in self.metadata.items():
+            if isinstance(value, list):
+                value = ", ".join(value)
+            md_content.append(f"{key}: {value}")
+        md_content.append("---\n")
+        
+        # Conteúdo por capítulo
+        for chapter in self.chapters:
+            md_content.append(f"# {chapter['title']}\n")
+            md_content.append(chapter['content'])
+            
+            if chapter['faqs']:
+                md_content.append("\n## FAQs\n")
+                for faq in chapter['faqs']:
+                    md_content.append(f"Q: {faq['question']}")
+                    md_content.append(f"A: {faq['answer']}\n")
+            
+            md_content.append("\n---\n")
+        
+        return "\n".join(md_content)
+
+    def save_output(self, output_file: str) -> None:
+        """Salva o conteúdo processado."""
+        markdown_content = self.generate_markdown()
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(markdown_content)
+
+    def save_markdown(self, output_file: str) -> None:
+        """
+        Guarda o conteúdo processado em formato Markdown.
+        
+        Args:
+            output_file (str): Caminho para o ficheiro de saída
+        """
+        # Criar diretório de saída se não existir
+        output_path = Path(output_file)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Gerar conteúdo em Markdown
+        markdown_content = self.generate_markdown()
+        
+        # Guardar ficheiro
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(markdown_content)

kb-processor/src/processors/db_processor.py

@@ -0,0 +1,132 @@
+"""
+Database Processor - Processador para interação com o PostgreSQL
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+import psycopg2
+from psycopg2.extras import Json, execute_values
+import json
+from datetime import datetime
+from typing import Dict, Any, Optional, List
+import os
+from dotenv import load_dotenv
+
+class DBProcessor:
+    """Processador para interação com o PostgreSQL."""
+    
+    def __init__(self):
+        """Inicializa a conexão com o banco de dados."""
+        # Configurações do banco de dados
+        self.db_config = {
+            'dbname': 'superbot_kb',
+            'user': 'superbot_user',
+            'password': 'KufQ4La5jaAk',
+            'host': 'easy.descomplicar.pt',
+            'port': '5433'
+        }
+        
+        # Inicializar conexão
+        self.conn = None
+        self.cur = None
+    
+    def connect(self) -> None:
+        """Estabelece conexão com o banco de dados."""
+        try:
+            self.conn = psycopg2.connect(**self.db_config)
+            self.cur = self.conn.cursor()
+        except Exception as e:
+            raise Exception(f"Erro ao conectar ao banco de dados: {str(e)}")
+    
+    def disconnect(self) -> None:
+        """Fecha a conexão com o banco de dados."""
+        if self.cur:
+            self.cur.close()
+        if self.conn:
+            self.conn.close()
+    
+    def init_schema(self) -> None:
+        """Inicializa o schema do banco de dados."""
+        try:
+            self.connect()
+            
+            # Criar extensão para vetores se não existir
+            self.cur.execute("""
+                CREATE EXTENSION IF NOT EXISTS vector;
+            """)
+            
+            # Criar tabela de documentos
+            self.cur.execute("""
+                CREATE TABLE IF NOT EXISTS documents (
+                    id SERIAL PRIMARY KEY,
+                    title VARCHAR(255) NOT NULL,
+                    content TEXT NOT NULL,
+                    metadata JSONB NOT NULL,
+                    file_path VARCHAR(255) NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );
+                
+                CREATE INDEX IF NOT EXISTS idx_documents_title ON documents(title);
+                CREATE INDEX IF NOT EXISTS idx_documents_metadata ON documents USING GIN(metadata);
+            """)
+            
+            # Criar tabela de embeddings
+            self.cur.execute("""
+                CREATE TABLE IF NOT EXISTS embeddings (
+                    id SERIAL PRIMARY KEY,
+                    document_id INTEGER REFERENCES documents(id) ON DELETE CASCADE,
+                    chunk_index INTEGER NOT NULL,
+                    chunk_text TEXT NOT NULL,
+                    embedding vector(1536),
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    UNIQUE(document_id, chunk_index)
+                );
+                
+                CREATE INDEX IF NOT EXISTS idx_embeddings_document_id ON embeddings(document_id);
+                CREATE INDEX IF NOT EXISTS idx_embeddings_embedding ON embeddings USING ivfflat (embedding vector_cosine_ops);
+            """)
+            
+            self.conn.commit()
+            
+        except Exception as e:
+            if self.conn:
+                self.conn.rollback()
+            raise Exception(f"Erro ao inicializar schema: {str(e)}")
+        finally:
+            self.disconnect()
+    
+    def save_document(self, title: str, content: str, metadata: Dict[str, Any], file_path: str) -> int:
+        """
+        Salva um documento no banco de dados.
+        
+        Args:
+            title (str): Título do documento
+            content (str): Conteúdo do documento
+            metadata (Dict[str, Any]): Metadados do documento
+            file_path (str): Caminho do arquivo original
+            
+        Returns:
+            int: ID do documento salvo
+        """
+        try:
+            self.connect()
+            
+            # Inserir documento
+            self.cur.execute("""
+                INSERT INTO documents (title, content, metadata, file_path)
+                VALUES (%s, %s, %s, %s)
+                RETURNING id;
+            """, (title, content, Json(metadata), file_path))
+            
+            document_id = self.cur.fetchone()[0]
+            self.conn.commit()
+            
+            return document_id
+            
+        except Exception as e:
+            if self.conn:
+                self.conn.rollback()
+            raise Exception(f"Erro ao salvar documento: {str(e)}")
+        finally:
+            self.disconnect()

kb-processor/src/processors/embedding_processor.py

@@ -0,0 +1,252 @@
+"""
+Embedding Processor - Processador para geração e gestão de embeddings
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+import requests
+import numpy as np
+from typing import List, Dict, Any, Optional
+import os
+from datetime import datetime
+import psycopg2
+from psycopg2.extras import Json, execute_values
+import json
+import tiktoken
+
+class EmbeddingProcessor:
+    """Processador para geração e gestão de embeddings."""
+    
+    def __init__(self):
+        """Inicializa o processador de embeddings."""
+        self.api_key = "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"
+        self.model = "text-embedding-ada-002"
+        self.encoding = tiktoken.encoding_for_model(self.model)
+        self.max_tokens = 8000  # Deixar margem de segurança
+        
+        # Configurações do banco de dados
+        self.db_config = {
+            'dbname': 'superbot_kb',
+            'user': 'superbot_user',
+            'password': 'KufQ4La5jaAk',
+            'host': 'easy.descomplicar.pt',
+            'port': '5433'
+        }
+        
+        # Inicializar conexão
+        self.conn = None
+        self.cur = None
+    
+    def connect(self) -> None:
+        """Estabelece conexão com o banco de dados."""
+        try:
+            self.conn = psycopg2.connect(**self.db_config)
+            self.cur = self.conn.cursor()
+        except Exception as e:
+            raise Exception(f"Erro ao conectar ao banco de dados: {str(e)}")
+    
+    def disconnect(self) -> None:
+        """Fecha a conexão com o banco de dados."""
+        if self.cur:
+            self.cur.close()
+        if self.conn:
+            self.conn.close()
+    
+    def split_text(self, text: str) -> List[str]:
+        """
+        Divide o texto em chunks menores respeitando o limite de tokens.
+        
+        Args:
+            text (str): Texto para dividir
+            
+        Returns:
+            List[str]: Lista de chunks de texto
+        """
+        tokens = self.encoding.encode(text)
+        chunks = []
+        current_chunk = []
+        current_size = 0
+        
+        for token in tokens:
+            if current_size + 1 > self.max_tokens:
+                # Converter tokens atuais para texto
+                chunk_text = self.encoding.decode(current_chunk)
+                chunks.append(chunk_text)
+                current_chunk = [token]
+                current_size = 1
+            else:
+                current_chunk.append(token)
+                current_size += 1
+        
+        # Adicionar último chunk
+        if current_chunk:
+            chunk_text = self.encoding.decode(current_chunk)
+            chunks.append(chunk_text)
+        
+        return chunks
+    
+    def generate_embedding(self, text: str) -> List[float]:
+        """
+        Gera embedding para um texto usando a API da OpenAI.
+        
+        Args:
+            text (str): Texto para gerar embedding
+            
+        Returns:
+            List[float]: Vetor de embedding
+        """
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}"
+            }
+            
+            data = {
+                "model": self.model,
+                "input": text
+            }
+            
+            response = requests.post(
+                "https://api.openai.com/v1/embeddings",
+                headers=headers,
+                json=data
+            )
+            
+            if response.status_code != 200:
+                raise Exception(f"API Error: {response.status_code} - {response.text}")
+            
+            return response.json()["data"][0]["embedding"]
+        except Exception as e:
+            raise Exception(f"Erro ao gerar embedding: {str(e)}")
+    
+    def update_document_embeddings(self, document_id: int) -> None:
+        """
+        Atualiza os embeddings de um documento.
+        
+        Args:
+            document_id (int): ID do documento
+        """
+        try:
+            # Conectar ao banco de dados
+            self.connect()
+            
+            # Buscar conteúdo do documento
+            self.cur.execute("""
+                SELECT content FROM documents
+                WHERE id = %s
+            """, (document_id,))
+            
+            result = self.cur.fetchone()
+            if not result:
+                raise Exception(f"Documento não encontrado: {document_id}")
+            
+            content = result[0]
+            
+            # Dividir em chunks
+            chunks = self.split_text(content)
+            print(f"Documento dividido em {len(chunks)} chunks")
+            
+            # Gerar embeddings para cada chunk
+            embeddings_data = []
+            for i, chunk in enumerate(chunks, 1):
+                print(f"Processando chunk {i}/{len(chunks)}...")
+                embedding = self.generate_embedding(chunk)
+                
+                embeddings_data.append({
+                    'document_id': document_id,
+                    'chunk_index': i-1,
+                    'chunk_text': chunk,
+                    'embedding': embedding
+                })
+            
+            # Salvar embeddings
+            self.cur.execute("""
+                DELETE FROM embeddings
+                WHERE document_id = %s
+            """, (document_id,))
+            
+            execute_values(
+                self.cur,
+                """
+                INSERT INTO embeddings (document_id, chunk_index, chunk_text, embedding)
+                VALUES %s
+                """,
+                [(
+                    d['document_id'],
+                    d['chunk_index'],
+                    d['chunk_text'],
+                    d['embedding']
+                ) for d in embeddings_data]
+            )
+            
+            self.conn.commit()
+            
+        except Exception as e:
+            if self.conn:
+                self.conn.rollback()
+            raise Exception(f"Erro ao atualizar embeddings: {str(e)}")
+        
+        finally:
+            self.disconnect()
+    
+    def search_similar(self, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """
+        Busca documentos similares à query.
+        
+        Args:
+            query (str): Texto para buscar
+            limit (int): Número máximo de resultados
+            
+        Returns:
+            List[Dict[str, Any]]: Lista de documentos similares
+        """
+        try:
+            # Gerar embedding para a query
+            query_embedding = self.generate_embedding(query)
+            
+            # Conectar ao banco de dados
+            self.connect()
+            
+            # Buscar chunks mais similares
+            self.cur.execute("""
+                WITH similarity AS (
+                    SELECT 
+                        d.id as document_id,
+                        d.title,
+                        d.metadata,
+                        e.chunk_text,
+                        1 - (e.embedding <=> %s) as similarity
+                    FROM embeddings e
+                    JOIN documents d ON e.document_id = d.id
+                    ORDER BY similarity DESC
+                    LIMIT 20
+                )
+                SELECT 
+                    document_id,
+                    title,
+                    metadata,
+                    array_agg(chunk_text ORDER BY similarity DESC) as chunks,
+                    max(similarity) as doc_similarity
+                FROM similarity
+                GROUP BY document_id, title, metadata
+                ORDER BY doc_similarity DESC
+                LIMIT %s
+            """, (query_embedding, limit))
+            
+            results = []
+            for row in self.cur.fetchall():
+                results.append({
+                    'document_id': row[0],
+                    'title': row[1],
+                    'metadata': row[2],
+                    'relevant_chunks': row[3],
+                    'doc_similarity': row[4]
+                })
+            
+            return results
+            
+        except Exception as e:
+            raise Exception(f"Erro ao buscar documentos: {str(e)}")
+        
+        finally:
+            self.disconnect()

kb-processor/src/processors/lead_distributor.py

@@ -0,0 +1,81 @@
+"""
+lead_distributor.py
+
+Author: Descomplicar® Crescimento Digital
+Link: https://descomplicar.pt
+Copyright: 2025 Descomplicar®
+"""
+
+"""
+Processador para distribuição inteligente de leads baseado em taxa de conversão.
+"""
+from typing import Dict, List
+
+class LeadDistributor:
+    def __init__(self):
+        self.vendedores: Dict[str, float] = {}  # {id_vendedor: taxa_conversao}
+        self.leads_distribuidos: Dict[str, int] = {}  # {id_vendedor: qtd_leads}
+        
+    def adicionar_vendedor(self, id_vendedor: str, taxa_conversao: float) -> None:
+        """Adiciona ou atualiza vendedor com sua taxa de conversão."""
+        self.vendedores[id_vendedor] = taxa_conversao
+        if id_vendedor not in self.leads_distribuidos:
+            self.leads_distribuidos[id_vendedor] = 0
+            
+    def calcular_quota_leads(self, id_vendedor: str) -> float:
+        """Calcula a quota de leads baseada na taxa de conversão."""
+        taxa = self.vendedores.get(id_vendedor, 0)
+        
+        # Baixa conversão: recebe menos leads
+        if taxa < 0.3:  # 30% de conversão como limite inferior
+            return 0.8  # 80% da quota normal
+        
+        # Alta conversão: recebe mais leads    
+        if taxa > 0.5:  # 50% de conversão como limite superior
+            return 1.2  # 120% da quota normal
+            
+        # Conversão média: quota normal
+        return 1.0
+        
+    def distribuir_leads(self, leads: List[dict]) -> Dict[str, List[dict]]:
+        """
+        Distribui leads entre vendedores baseado em suas taxas de conversão.
+        
+        Args:
+            leads: Lista de dicionários contendo informações dos leads
+            
+        Returns:
+            Dicionário com leads distribuídos por vendedor
+        """
+        if not self.vendedores:
+            raise ValueError("Nenhum vendedor registrado no sistema")
+            
+        distribuicao: Dict[str, List[dict]] = {id_v: [] for id_v in self.vendedores}
+        
+        # Calcula quotas totais para distribuição proporcional
+        quotas = {id_v: self.calcular_quota_leads(id_v) for id_v in self.vendedores}
+        total_quotas = sum(quotas.values())
+        
+        # Distribui leads proporcionalmente às quotas
+        for lead in leads:
+            # Encontra vendedor com menos leads relativos à sua quota
+            vendedor_escolhido = min(
+                self.vendedores.keys(),
+                key=lambda v: len(distribuicao[v]) / quotas[v]
+            )
+            
+            distribuicao[vendedor_escolhido].append(lead)
+            self.leads_distribuidos[vendedor_escolhido] += 1
+            
+        return distribuicao
+        
+    def obter_estatisticas(self) -> Dict[str, dict]:
+        """Retorna estatísticas de distribuição de leads por vendedor."""
+        return {
+            id_v: {
+                "taxa_conversao": self.vendedores[id_v],
+                "leads_recebidos": self.leads_distribuidos[id_v],
+                "quota_atual": self.calcular_quota_leads(id_v)
+            }
+            for id_v in self.vendedores
+        }

kb-processor/src/processors/pdf_processor.py

@@ -0,0 +1,142 @@
+"""
+PDF Processor - Módulo para processamento de documentos PDF
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+from PyPDF2 import PdfReader
+from typing import List, Dict
+from datetime import datetime
+from openai import OpenAI
+from .base_processor import BaseProcessor
+
+class PDFProcessor(BaseProcessor):
+    """Processador específico para documentos PDF."""
+    
+    def __init__(self, filepath: str):
+        """
+        Inicializa o processador PDF.
+        
+        Args:
+            filepath (str): Caminho para o arquivo PDF
+        """
+        super().__init__(filepath)
+        self.filepath = filepath
+        self.pdf_reader = None
+        self.num_pages = 0
+        self.content = ""
+        
+        # Configurar cliente OpenAI para traduções
+        self.translator = OpenAI(
+            api_key="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"
+        )
+        
+        # Atualizar metadata
+        self.metadata.update({
+            "tipo_documento": "pdf",
+            "fonte": filepath,
+            "data_original": datetime.now().strftime("%d-%m-%Y")
+        })
+        
+    def read_content(self) -> str:
+        """
+        Lê o conteúdo do PDF.
+        
+        Returns:
+            str: Conteúdo do PDF
+        """
+        try:
+            # Abrir PDF
+            self.pdf_reader = PdfReader(self.filepath)
+            self.num_pages = len(self.pdf_reader.pages)
+            
+            # Extrair texto por página
+            content = []
+            for page in self.pdf_reader.pages:
+                text = page.extract_text()
+                if text.strip():
+                    content.append(text)
+            
+            # Juntar todo o conteúdo
+            self.content = "\n\n".join(content)
+            return self.content
+            
+        except Exception as e:
+            print(f"Erro ao ler PDF: {str(e)}")
+            return ""
+            
+    def process_content(self) -> None:
+        """Processa o conteúdo do PDF."""
+        try:
+            if not self.content:
+                self.read_content()
+                
+            # Traduzir conteúdo se necessário
+            response = self.translator.chat.completions.create(
+                model="gpt-4",
+                messages=[
+                    {"role": "system", "content": "És um tradutor profissional. Traduz o texto para português de Portugal, mantendo termos técnicos em inglês quando apropriado."},
+                    {"role": "user", "content": self.content}
+                ]
+            )
+            translated_text = response.choices[0].message.content
+            self.content = translated_text
+            
+            # Gerar FAQs do conteúdo
+            self.faqs = self.generate_faqs(self.content)
+            
+            # Atualizar metadata
+            self.metadata.update({
+                "num_paginas": self.num_pages,
+                "num_faqs": len(self.faqs)
+            })
+            
+        except Exception as e:
+            print(f"Erro ao processar PDF: {str(e)}")
+            
+    def generate_faqs(self, content: str, num_faqs: int = 3) -> List[Dict[str, str]]:
+        """
+        Gera FAQs a partir do conteúdo.
+        
+        Args:
+            content (str): Texto para gerar FAQs
+            num_faqs (int): Número de FAQs a gerar
+            
+        Returns:
+            List[Dict[str, str]]: Lista de FAQs geradas
+        """
+        try:
+            # Limitar tamanho do conteúdo
+            max_chars = 2000
+            if len(content) > max_chars:
+                content = content[:max_chars] + "..."
+            
+            # Gerar FAQs usando OpenAI
+            response = self.translator.chat.completions.create(
+                model="gpt-4",
+                messages=[
+                    {"role": "system", "content": "És um especialista em documentação técnica. Gera FAQs relevantes em português de Portugal."},
+                    {"role": "user", "content": f"Gera {num_faqs} FAQs técnicas e diretas sobre:\n\n{content}"}
+                ]
+            )
+            
+            # Processar resposta
+            raw_faqs = response.choices[0].message.content.strip().split('\n\n')
+            faqs = []
+            
+            for raw_faq in raw_faqs[:num_faqs]:
+                if raw_faq.startswith('P:'):
+                    parts = raw_faq.split('\nR:')
+                    if len(parts) == 2:
+                        question = parts[0].replace('P:', '').strip()
+                        answer = parts[1].strip()
+                        faqs.append({
+                            'question': question,
+                            'answer': answer
+                        })
+            
+            return faqs
+            
+        except Exception as e:
+            print(f"Erro ao gerar FAQs: {str(e)}")
+            return []

kb-processor/src/processors/text_corrector.py

@@ -0,0 +1,399 @@
+"""
+Text Corrector - Processador para correção e formatação de texto
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+import httpx
+import json
+from typing import Dict, Any, Optional
+import os
+from pathlib import Path
+import time
+import re
+import concurrent.futures
+
+class TextCorrector:
+    """Processador para correção e formatação de texto usando OpenRouter."""
+    
+    def __init__(self):
+        """Inicializa o corretor de texto."""
+        self.api_key = "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"
+        self.api_url = "https://openrouter.ai/api/v1/chat/completions"
+        self.model = "mistralai/mistral-7b-instruct"  # ID correto do modelo
+        self.max_chunk_size = 12000  # Mistral suporta contextos maiores
+        
+        # Prompt otimizado para o Mistral
+        self.system_prompt_correction = """Você é um revisor especializado em melhorar documentação técnica em Markdown.
+Corrija e formate o texto mantendo estas regras:
+
+1. FORMATAÇÃO MARKDOWN:
+   - Use # para títulos e subtítulos
+   - Use ** para negrito em termos importantes
+   - Use ` para código inline
+   - Use ``` para blocos de código
+   - Use > para citações
+   - Use - ou * para listas
+   - Use --- para separadores
+   - Preserve todas as URLs existentes
+
+2. ESTRUTURA:
+   - Organize em seções com títulos claros
+   - Use parágrafos para separar ideias
+   - Mantenha listas e enumerações
+   - Preserve a hierarquia de títulos
+
+3. CONTEÚDO:
+   - Corrija erros de pontuação e gramática
+   - Mantenha todos os termos técnicos inalterados
+   - Preserve comandos e códigos exatamente como estão
+   - Mantenha URLs e referências intactas
+
+Retorne o texto mantendo toda a formatação Markdown."""
+
+        # Prompt de tradução otimizado
+        self.system_prompt_translation = """Traduza para português de Portugal mantendo a formatação Markdown.
+
+1. FORMATAÇÃO:
+   - Preserve todos os elementos Markdown (# ** ` [] () etc)
+   - Mantenha a estrutura de títulos e seções
+   - Preserve blocos de código sem traduzir
+
+2. TRADUÇÃO:
+   - Use português europeu (não brasileiro)
+   - Mantenha termos técnicos em inglês
+   - Preserve comandos e códigos inalterados
+   - Mantenha URLs intactas
+
+Retorne o texto traduzido com toda a formatação Markdown."""
+
+        # Prompt PT-PT otimizado
+        self.system_prompt_ptpt = """Converta para português de Portugal mantendo a formatação Markdown.
+
+1. FORMATAÇÃO:
+   - Preserve todos os elementos Markdown (# ** ` [] () etc)
+   - Mantenha a estrutura de títulos e seções
+   - Preserve blocos de código sem alterar
+
+2. CONVERSÃO:
+   - Substitua brasileirismos por termos portugueses
+   - Use terminologia técnica portuguesa
+   - Mantenha comandos e códigos inalterados
+   - Preserve URLs e referências
+
+Retorne o texto convertido com toda a formatação Markdown."""
+
+        # Compilar expressões regulares para melhor performance
+        self.space_pattern = re.compile(r'\s+')
+        self.punct_pattern = re.compile(r'([.,!?;:])\s*')
+        self.newline_pattern = re.compile(r'\n{3,}')
+        self.url_pattern = re.compile(r'https?://\S+')
+        
+        # Cache para resultados
+        self._cache = {}
+    
+    def is_english(self, text: str) -> bool:
+        """
+        Verifica se o texto está em inglês.
+        Usa uma heurística baseada em palavras e expressões comuns.
+        """
+        # Palavras muito comuns em inglês que raramente aparecem em português
+        english_words = {
+            'the', 'this', 'these', 'those', 'which', 'what', 'where', 'when', 'why',
+            'how', 'who', 'whom', 'whose', 'that', 'there', 'here', 'they', 'them',
+            'their', 'his', 'her', 'its', 'our', 'your', 'my', 'we', 'you', 'he',
+            'she', 'it', 'they', 'am', 'is', 'are', 'was', 'were', 'been', 'being'
+        }
+        
+        # Palavras comuns em português (pt-BR e pt-PT)
+        portuguese_words = {
+            'de', 'da', 'do', 'das', 'dos', 'em', 'no', 'na', 'nos', 'nas',
+            'um', 'uma', 'uns', 'umas', 'que', 'qual', 'quais', 'quando',
+            'onde', 'como', 'por', 'para', 'pelo', 'pela', 'pelos', 'pelas',
+            'este', 'esta', 'estes', 'estas', 'esse', 'essa', 'esses', 'essas',
+            'isto', 'isso', 'aquilo', 'também', 'mas', 'ou', 'porque', 'pois',
+            'já', 'só', 'ainda', 'mesmo', 'assim', 'então', 'agora', 'depois'
+        }
+        
+        # Converter texto para minúsculas e dividir em palavras
+        words = set(re.findall(r'\b\w+\b', text.lower()))
+        
+        # Contar ocorrências de palavras em cada idioma
+        english_count = len(words.intersection(english_words))
+        portuguese_count = len(words.intersection(portuguese_words))
+        
+        # Se tiver significativamente mais palavras em inglês, considera como inglês
+        # Ajustado para evitar falsos positivos com português
+        return english_count > portuguese_count * 1.5 and english_count > 5
+    
+    def is_brazilian(self, text: str) -> bool:
+        """
+        Verifica se o texto está em português do Brasil.
+        """
+        # Palavras e expressões típicas do português brasileiro
+        br_words = {
+            'você', 'vocês', 'pra', 'tá', 'né', 'cara', 'beleza', 'legal',
+            'valeu', 'bacana', 'gente', 'galera', 'pessoal', 'aqui', 'agora',
+            'então', 'tipo', 'tava', 'tavam', 'vamo', 'vamos', 'cadê',
+            'aí', 'daí', 'meu', 'mano', 'brother', 'mina', 'cara', 'véi',
+            'massa', 'maneiro', 'show', 'tranquilo', 'suave', 'firmeza'
+        }
+        
+        # Converter texto para minúsculas e dividir em palavras
+        words = set(re.findall(r'\b\w+\b', text.lower()))
+        
+        # Se encontrar algumas palavras típicas do BR, considera como pt-BR
+        br_count = len(words.intersection(br_words))
+        return br_count >= 3  # Se encontrar 3 ou mais palavras típicas do BR
+    
+    def correct_text(self, text: str, max_retries: int = 3) -> str:
+        """
+        Corrige e formata um texto usando a API da OpenRouter.
+        
+        Args:
+            text (str): Texto para corrigir
+            max_retries (int): Número máximo de tentativas em caso de erro
+            
+        Returns:
+            str: Texto corrigido e formatado
+        """
+        # Verificar cache
+        if text in self._cache:
+            return self._cache[text]
+        
+        # Verificar idioma
+        is_eng = self.is_english(text)
+        is_br = self.is_brazilian(text)
+        
+        if is_eng:
+            print("Texto em inglês detectado, será traduzido para português...")
+        elif is_br:
+            print("Texto em português do Brasil detectado, será convertido para português de Portugal...")
+        else:
+            print("Processando texto em português de Portugal...")
+        
+        # Dividir texto em chunks se necessário
+        if len(text) > self.max_chunk_size:
+            print("Texto muito grande, dividindo em partes...")
+            chunks = self.split_text(text)
+            processed_chunks = []
+            
+            for i, chunk in enumerate(chunks, 1):
+                print(f"Processando parte {i} de {len(chunks)}...")
+                if is_eng:
+                    # Se for inglês: corrige -> traduz
+                    corrected = self._process_chunk(chunk, max_retries, self.system_prompt_correction)
+                    processed = self._process_chunk(corrected, max_retries, self.system_prompt_translation)
+                elif is_br:
+                    # Se for pt-BR: corrige -> converte para pt-PT
+                    corrected = self._process_chunk(chunk, max_retries, self.system_prompt_correction)
+                    processed = self._process_chunk(corrected, max_retries, self.system_prompt_ptpt)
+                else:
+                    # Se for pt-PT: apenas corrige
+                    processed = self._process_chunk(chunk, max_retries, self.system_prompt_correction)
+                processed_chunks.append(processed)
+            
+            # Aplicar correções adicionais
+            result = "\n\n".join(processed_chunks)
+            result = self.correct_text_additions(result)
+            
+            # Armazenar no cache
+            self._cache[text] = result
+            
+            return result
+        
+        # Processar texto completo
+        if is_eng:
+            corrected = self._process_chunk(text, max_retries, self.system_prompt_correction)
+            result = self._process_chunk(corrected, max_retries, self.system_prompt_translation)
+        elif is_br:
+            corrected = self._process_chunk(text, max_retries, self.system_prompt_correction)
+            result = self._process_chunk(corrected, max_retries, self.system_prompt_ptpt)
+        else:
+            result = self._process_chunk(text, max_retries, self.system_prompt_correction)
+        
+        # Aplicar correções adicionais
+        result = self.correct_text_additions(result)
+        
+        # Armazenar no cache
+        self._cache[text] = result
+        
+        return result
+    
+    def correct_text_additions(self, text: str) -> str:
+        """Aplica correções adicionais ao texto."""
+        # Preservar URLs
+        urls = self.url_pattern.findall(text)
+        for i, url in enumerate(urls):
+            text = text.replace(url, f"__URL_{i}__")
+        
+        # Aplicar correções
+        text = text.strip()
+        text = self.space_pattern.sub(' ', text)
+        text = self.punct_pattern.sub(r'\1 ', text)
+        text = self.newline_pattern.sub('\n\n', text)
+        
+        # Restaurar URLs
+        for i, url in enumerate(urls):
+            text = text.replace(f"__URL_{i}__", url)
+        
+        return text
+    
+    def split_text(self, text: str) -> list[str]:
+        """Divide o texto em chunks menores."""
+        words = text.split()
+        chunks = []
+        current_chunk = []
+        current_length = 0
+        
+        for word in words:
+            word_length = len(word) + 1  # +1 para o espaço
+            if current_length + word_length > self.max_chunk_size:
+                chunks.append(' '.join(current_chunk))
+                current_chunk = [word]
+                current_length = word_length
+            else:
+                current_chunk.append(word)
+                current_length += word_length
+        
+        if current_chunk:
+            chunks.append(' '.join(current_chunk))
+        
+        return chunks
+    
+    def _process_chunk(self, text: str, max_retries: int, system_prompt: str) -> str:
+        """Processa um chunk de texto."""
+        headers = {
+            "HTTP-Referer": "https://www.descomplicar.pt/",
+            "X-Title": "SuperBot KB",
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        data = {
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": f"Corrija e formate este texto:\n\n{text}"}
+            ]
+        }
+        
+        for attempt in range(max_retries):
+            try:
+                with httpx.Client(timeout=120.0) as client:
+                    response = client.post(
+                        self.api_url,
+                        headers=headers,
+                        json=data
+                    )
+                    
+                    if response.status_code == 200:
+                        result = response.json()
+                        # Tentar diferentes formatos de resposta
+                        if 'choices' in result and len(result['choices']) > 0:
+                            if 'message' in result['choices'][0]:
+                                return result['choices'][0]['message']['content']
+                            elif 'text' in result['choices'][0]:
+                                return result['choices'][0]['text']
+                        elif 'response' in result:
+                            return result['response']
+                        
+                        print(f"Formato de resposta inesperado: {result}")
+                        raise Exception("Formato de resposta inválido")
+                        
+                    elif response.status_code == 401:
+                        print(f"Erro de autenticação. Verifique a chave da API.")
+                        raise Exception("Erro de autenticação na OpenRouter")
+                    else:
+                        print(f"Erro {response.status_code}: {response.text}")
+                        if attempt < max_retries - 1:
+                            time.sleep(5)
+                        continue
+                        
+            except Exception as e:
+                print(f"Erro ao processar texto: {str(e)}")
+                if attempt < max_retries - 1:
+                    time.sleep(5)
+                continue
+        
+        raise Exception("Falha ao processar texto após várias tentativas")
+    
+    def process_file(self, input_file: str, output_file: str) -> None:
+        """
+        Processa um arquivo de texto, corrigindo e formatando seu conteúdo.
+        
+        Args:
+            input_file (str): Caminho do arquivo de entrada
+            output_file (str): Caminho do arquivo de saída
+        """
+        try:
+            # Ler arquivo de entrada
+            with open(input_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            # Corrigir texto
+            print(f"Processando texto de {input_file}...")
+            corrected_text = self.correct_text(content)
+            
+            # Salvar resultado
+            with open(output_file, 'w', encoding='utf-8') as f:
+                f.write(corrected_text)
+            
+            print(f"Texto processado salvo em {output_file}")
+            
+        except Exception as e:
+            raise Exception(f"Erro ao processar arquivo: {str(e)}")
+    
+    def process_directory(self, input_dir: str, output_dir: str) -> None:
+        """
+        Processa todos os arquivos .txt em um diretório.
+        
+        Args:
+            input_dir (str): Diretório com os arquivos originais
+            output_dir (str): Diretório para salvar os arquivos corrigidos
+        """
+        from pathlib import Path
+        
+        input_path = Path(input_dir)
+        output_path = Path(output_dir)
+        output_path.mkdir(exist_ok=True)
+        
+        def process_file(file: Path) -> None:
+            try:
+                # Ler arquivo
+                text = file.read_text(encoding='utf-8')
+                
+                # Corrigir texto
+                corrected = self.correct_text(text)
+                
+                # Salvar resultado
+                output_file = output_path / f"corrigido_{file.name}"
+                output_file.write_text(corrected, encoding='utf-8')
+                
+            except Exception as e:
+                print(f"Erro ao processar {file.name}: {str(e)}")
+        
+        # Processar arquivos em paralelo
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            files = list(input_path.glob('*.txt'))
+            executor.map(process_file, files)
+
+if __name__ == "__main__":
+    # Criar uma instância do corretor
+    corrector = TextCorrector()
+    
+    # Solicitar texto do usuário
+    print("Digite ou cole o texto a ser corrigido (Ctrl+D para terminar):")
+    try:
+        texto = ""
+        while True:
+            linha = input()
+            texto += linha + "\n"
+    except EOFError:
+        pass
+    
+    # Corrigir e mostrar o resultado
+    texto_corrigido = corrector.correct_text(texto)
+    print("\nTexto Corrigido:")
+    print("="*50)
+    print(texto_corrigido)

kb-processor/src/processors/txt_processor.py

@@ -0,0 +1,97 @@
+"""
+Text Processor - Processador para ficheiros TXT
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+import os
+from datetime import datetime
+from typing import Dict, Any
+import re
+
+class TXTProcessor:
+    """Processador para ficheiros TXT."""
+    
+    def __init__(self, file_path: str):
+        """
+        Inicializa o processador.
+        
+        Args:
+            file_path (str): Caminho para o ficheiro TXT
+        """
+        self.file_path = file_path
+        self.content = ""
+        self.metadata = {}
+    
+    def process_content(self) -> None:
+        """Processa o conteúdo do ficheiro TXT."""
+        try:
+            # Ler o ficheiro
+            with open(self.file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            # Extrair metadados do início do ficheiro se existirem
+            metadata_match = re.match(r'^---\n(.*?)\n---\n(.*)', content, re.DOTALL)
+            
+            if metadata_match:
+                # Processar metadados em formato YAML
+                metadata_text = metadata_match.group(1)
+                self.content = metadata_match.group(2).strip()
+                
+                # Extrair metadados
+                for line in metadata_text.split('\n'):
+                    if ':' in line:
+                        key, value = line.split(':', 1)
+                        self.metadata[key.strip()] = value.strip()
+            else:
+                # Se não houver metadados, usar todo o conteúdo
+                self.content = content.strip()
+            
+            # Gerar metadados automáticos
+            self._generate_metadata()
+            
+        except Exception as e:
+            raise Exception(f"Erro ao processar ficheiro TXT: {str(e)}")
+    
+    def _generate_metadata(self) -> None:
+        """Gera metadados automáticos."""
+        # Nome do ficheiro como título se não especificado
+        if 'título' not in self.metadata:
+            self.metadata['título'] = os.path.splitext(os.path.basename(self.file_path))[0]
+        
+        # Metadados padrão
+        self.metadata.update({
+            'autor_original': self.metadata.get('autor_original', 'Descomplicar AI'),
+            'data_original': self.metadata.get('data_original', datetime.now().strftime('%d-%m-%Y')),
+            'tipo_documento': self.metadata.get('tipo_documento', 'Documento de Texto'),
+            'fonte': self.metadata.get('fonte', 'Descomplicar - Agência de Aceleração Digital'),
+            'licença': self.metadata.get('licença', 'Copyright Descomplicar'),
+            'última_atualização': datetime.now().strftime('%d-%m-%Y'),
+            'categoria_principal': self.metadata.get('categoria_principal', 'Documentação Técnica'),
+            'tags': self.metadata.get('tags', []),
+            'nível_técnico': self.metadata.get('nível_técnico', 'Básico'),
+            'idioma_original': self.metadata.get('idioma_original', 'Português'),
+            'tradutor': self.metadata.get('tradutor', 'Descomplicar AI'),
+            'revisão': self.metadata.get('revisão', '1.0')
+        })
+    
+    def save_markdown(self, output_file: str) -> None:
+        """
+        Salva o conteúdo processado em formato markdown.
+        
+        Args:
+            output_file (str): Caminho para o ficheiro de saída
+        """
+        try:
+            with open(output_file, 'w', encoding='utf-8') as f:
+                # Adicionar metadados
+                f.write('---\n')
+                for key, value in self.metadata.items():
+                    f.write(f'{key}: {value}\n')
+                f.write('---\n\n')
+                
+                # Adicionar conteúdo
+                f.write(self.content)
+                
+        except Exception as e:
+            raise Exception(f"Erro ao salvar markdown: {str(e)}")

kb-processor/src/processors/web_processor.py

@@ -0,0 +1,213 @@
+"""
+Web Processor - Módulo para processamento de conteúdo web
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin, urlparse
+from typing import List, Dict
+from datetime import datetime
+from openai import OpenAI
+from .base_processor import BaseProcessor
+import time
+
+class WebProcessor(BaseProcessor):
+    """Processador específico para conteúdo web."""
+    
+    def __init__(self, url: str):
+        """
+        Inicializa o processador web.
+        
+        Args:
+            url (str): URL do conteúdo web
+        """
+        super().__init__(url)
+        self.url = url
+        self.base_domain = urlparse(url).netloc
+        self.soup = None
+        self.links = []
+        self.images = []
+        
+        # Configurar cliente OpenAI para traduções
+        self.translator = OpenAI(
+            api_key="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"
+        )
+        
+        # Atualizar metadata
+        self.metadata.update({
+            "tipo_documento": "web",
+            "fonte": url,
+            "data_original": datetime.now().strftime("%d-%m-%Y")
+        })
+    
+    def translate_batch(self, texts: List[str]) -> List[str]:
+        """
+        Traduz um lote de textos de uma vez.
+        
+        Args:
+            texts (List[str]): Lista de textos para traduzir
+            
+        Returns:
+            List[str]: Lista de textos traduzidos
+        """
+        if not texts:
+            return []
+            
+        # Juntar textos com marcadores
+        combined_text = "\n---SPLIT---\n".join(texts)
+        
+        try:
+            response = self.translator.chat.completions.create(
+                model="gpt-4",
+                messages=[
+                    {"role": "system", "content": "Traduza o seguinte texto para português de Portugal. Mantenha termos técnicos em inglês quando apropriado. Mantenha os marcadores ---SPLIT--- para separar os textos:"},
+                    {"role": "user", "content": combined_text}
+                ]
+            )
+            
+            # Separar textos traduzidos
+            translated = response.choices[0].message.content.split("\n---SPLIT---\n")
+            return [t.strip() for t in translated]
+            
+        except Exception as e:
+            print(f"Erro ao traduzir textos: {str(e)}")
+            return texts
+    
+    def read_content(self) -> str:
+        """
+        Lê o conteúdo da URL.
+        
+        Returns:
+            str: Conteúdo da página web
+        """
+        try:
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+            }
+            response = requests.get(self.url, headers=headers, timeout=30)
+            response.raise_for_status()
+            return response.text
+        except Exception as e:
+            print(f"Erro ao ler URL {self.url}: {str(e)}")
+            return ""
+    
+    def process_content(self):
+        """Processa o conteúdo web."""
+        start_time = time.time()
+        
+        # Definir timeout de 5 minutos
+        timeout = 300
+        
+        html = self.read_content()
+        if not html:
+            return
+            
+        self.soup = BeautifulSoup(html, 'html.parser')
+        
+        # Extrair título
+        title = self.soup.title.string if self.soup.title else "Sem título"
+        self.metadata["título"] = title.strip()
+        
+        # Extrair texto principal
+        self.content = self._extract_main_content()
+        
+        # Extrair links importantes
+        self._extract_links()
+        
+        # Dividir em secções
+        self._split_into_sections()
+        
+        # Verificar timeout
+        if time.time() - start_time > timeout:
+            print("Tempo limite excedido. Interrompendo processamento.")
+            return
+    
+    def _extract_main_content(self) -> str:
+        """
+        Extrai o conteúdo principal da página.
+        
+        Returns:
+            str: Texto principal da página
+        """
+        # Remover elementos indesejados
+        for elem in self.soup.select('script, style, nav, footer, header, .sidebar, .menu, .ads'):
+            elem.decompose()
+        
+        # Tentar encontrar o conteúdo principal
+        main_content = None
+        for selector in ['article', 'main', '.content', '.main-content', '#content', '#main']:
+            main_content = self.soup.select_one(selector)
+            if main_content:
+                break
+        
+        # Se não encontrar conteúdo principal, usar body
+        if not main_content:
+            main_content = self.soup.body
+        
+        # Extrair texto
+        if main_content:
+            # Extrair apenas parágrafos e cabeçalhos relevantes
+            elements = main_content.find_all(['p', 'h1', 'h2', 'h3', 'li'])
+            texts = [elem.get_text(strip=True) for elem in elements]
+            texts = [t for t in texts if len(t) > 20]  # Filtrar textos muito curtos
+            
+            # Traduzir em lotes de 5 textos
+            batch_size = 5
+            translated_texts = []
+            for i in range(0, len(texts), batch_size):
+                batch = texts[i:i + batch_size]
+                translated_batch = self.translate_batch(batch)
+                translated_texts.extend(translated_batch)
+            
+            return '\n\n'.join(translated_texts)
+        
+        return ""
+    
+    def _extract_links(self):
+        """Extrai links importantes da página."""
+        main_content = self.soup.select_one('article, main, .content, #content')
+        if not main_content:
+            return
+            
+        for link in main_content.find_all('a', href=True):
+            href = link.get('href')
+            text = link.get_text(strip=True)
+            if href and text and len(text) > 5:  # Ignorar links muito curtos
+                absolute_url = urljoin(self.url, href)
+                if urlparse(absolute_url).netloc == self.base_domain:
+                    self.links.append({
+                        'text': text,
+                        'url': absolute_url
+                    })
+    
+    def _split_into_sections(self):
+        """Divide o conteúdo em secções baseado em cabeçalhos."""
+        if not self.content:
+            return
+            
+        # Dividir por linhas vazias para encontrar parágrafos
+        paragraphs = [p.strip() for p in self.content.split('\n\n') if p.strip()]
+        
+        current_section = {
+            'title': self.metadata['título'],
+            'content': '',
+            'faqs': []
+        }
+        
+        for p in paragraphs:
+            # Se o parágrafo parece um título (curto e termina sem pontuação)
+            if len(p) < 100 and not p[-1] in '.!?':
+                if current_section['content']:
+                    self.chapters.append(current_section)
+                current_section = {
+                    'title': p,
+                    'content': '',
+                    'faqs': []
+                }
+            else:
+                current_section['content'] += p + '\n\n'
+        
+        if current_section['content']:
+            self.chapters.append(current_section)

kb-processor/src/processors/youtube_processor.py

@@ -0,0 +1,243 @@
+"""
+youtube_processor.py
+
+Author: Descomplicar® Crescimento Digital
+Link: https://descomplicar.pt
+Copyright: 2025 Descomplicar®
+"""
+
+"""
+YouTube Processor
+Processa vídeos, playlists e canais do YouTube extraindo suas transcrições.
+"""
+
+from youtube_transcript_api import YouTubeTranscriptApi
+import yt_dlp
+import re
+from datetime import datetime
+import os
+from typing import Dict, List, Optional, Tuple, Callable
+
+from .base_processor import BaseProcessor
+from .text_corrector import TextCorrector
+
+class YouTubeProcessor(BaseProcessor):
+    """Processador para conteúdo do YouTube."""
+    
+    def __init__(self, url: str, progress_callback: Callable[[str, int], None] = None):
+        """
+        Inicializa o processador com a URL do YouTube.
+        
+        Args:
+            url: URL do vídeo/playlist do YouTube
+            progress_callback: Função de callback para atualizar o progresso
+                             Recebe (fase: str, progresso: int)
+        """
+        super().__init__(url)
+        self.url = url
+        self.info = None
+        self.transcripts = []
+        self.metadata = {}
+        self.text_corrector = TextCorrector()
+        self.progress_callback = progress_callback or (lambda fase, prog: None)
+        
+        # Define as fases do processamento
+        self.fases = {
+            'extract_id': 'Extraindo ID do vídeo',
+            'get_info': 'Obtendo informações',
+            'process_video': 'Processando vídeo',
+            'get_transcript': 'Obtendo transcrição',
+            'correct_text': 'Corrigindo texto',
+            'update_metadata': 'Atualizando metadados'
+        }
+
+    def extract_video_id(self, url: str) -> str:
+        """Extrai o ID do vídeo da URL do YouTube."""
+        patterns = [
+            r'(?:v=|\/)([0-9A-Za-z_-]{11}).*',
+            r'(?:youtu\.be\/)([0-9A-Za-z_-]{11})',
+            r'(?:embed\/)([0-9A-Za-z_-]{11})'
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, url)
+            if match:
+                return match.group(1)
+        return None
+
+    def get_video_info(self, url: str) -> Dict:
+        """Obtém informações do vídeo usando yt-dlp."""
+        ydl_opts = {
+            'quiet': True,
+            'no_warnings': True,
+            'extract_flat': True
+        }
+        
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            try:
+                return ydl.extract_info(url, download=False)
+            except Exception as e:
+                print(f"Erro ao obter informações do vídeo: {e}")
+                return None
+
+    def process_video(self, video_id: str, language: str = None) -> Optional[Dict]:
+        """Processa um único vídeo do YouTube."""
+        try:
+            self.progress_callback('get_transcript', 0)
+            transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
+            
+            self.progress_callback('get_transcript', 20)
+            # Tenta obter a transcrição na língua desejada
+            if language:
+                try:
+                    transcript = transcript_list.find_transcript([language])
+                except:
+                    transcript = transcript_list.find_transcript(['en', 'pt'])
+                    transcript = transcript.translate(language)
+            else:
+                transcript = transcript_list.find_transcript(['pt', 'en'])
+            
+            self.progress_callback('get_transcript', 40)
+            transcript_data = transcript.fetch()
+            
+            self.progress_callback('get_transcript', 60)
+            full_text = ""
+            for entry in transcript_data:
+                text = entry.get('text', '').strip()
+                if text:
+                    full_text += text + " "
+            
+            self.progress_callback('correct_text', 0)
+            corrected_text = self.text_corrector.correct_text(full_text)
+            self.progress_callback('correct_text', 100)
+            
+            return {
+                'video_id': video_id,
+                'language': transcript.language,
+                'content': corrected_text
+            }
+            
+        except Exception as e:
+            print(f"Erro ao processar transcrição: {str(e)}")
+            return None
+
+    def process_content(self, progress_callback=None) -> None:
+        """
+        Processa o conteúdo do YouTube.
+        
+        Args:
+            progress_callback: Função opcional para reportar progresso.
+                             Se fornecido, substitui o callback definido no construtor.
+        """
+        # Usa o callback fornecido ou o definido no construtor
+        callback = progress_callback or self.progress_callback
+        
+        # Extrai ID do vídeo
+        callback('extract_id', 0)
+        video_id = self.extract_video_id(self.url)
+        if not video_id:
+            raise ValueError("URL do YouTube inválida")
+        callback('extract_id', 100)
+        
+        # Obtém informações do vídeo
+        callback('get_info', 0)
+        self.info = self.get_video_info(self.url)
+        if not self.info:
+            raise ValueError("Não foi possível obter informações do vídeo")
+        callback('get_info', 100)
+        
+        # Processa vídeo único
+        if '_type' not in self.info or self.info['_type'] == 'video':
+            callback('process_video', 0)
+            transcript = self.process_video(video_id)
+            if transcript:
+                self.transcripts.append(transcript)
+            callback('process_video', 100)
+        
+        # Processa playlist
+        elif self.info['_type'] == 'playlist':
+            total_videos = len(self.info['entries'])
+            for i, entry in enumerate(self.info['entries'], 1):
+                progress = int((i-1) * 100 / total_videos)
+                callback('process_video', progress)
+                
+                video_id = entry['id']
+                transcript = self.process_video(video_id)
+                if transcript:
+                    self.transcripts.append(transcript)
+            
+            callback('process_video', 100)
+        
+        # Atualiza metadados
+        callback('update_metadata', 0)
+        self.metadata = {
+            'title': self.info.get('title', ''),
+            'uploader': self.info.get('uploader', ''),
+            'upload_date': self.info.get('upload_date', ''),
+            'videos': []
+        }
+        
+        for transcript in self.transcripts:
+            video_url = f"https://www.youtube.com/watch?v={transcript['video_id']}"
+            video_info = {
+                'url': video_url,
+                'language': transcript['language']
+            }
+            self.metadata['videos'].append(video_info)
+        
+        callback('update_metadata', 100)
+
+    def read_content(self) -> str:
+        """
+        Método abstrato implementado para ler o conteúdo do YouTube.
+        Retorna o conteúdo combinado de todas as transcrições.
+        """
+        if not self.transcripts:
+            self.process_content()
+        
+        if not self.transcripts:
+            return "Nenhuma transcrição encontrada."
+        
+        # Combina todas as transcrições em um único texto
+        combined_text = []
+        
+        for transcript in self.transcripts:
+            video_url = f"https://www.youtube.com/watch?v={transcript['video_id']}"
+            combined_text.extend([
+                f"\n## Vídeo: {video_url}",
+                f"Idioma original: {transcript['language']}\n",
+                transcript['content'],
+                "\n---\n"
+            ])
+        
+        return '\n'.join(combined_text)
+
+    def to_markdown(self) -> str:
+        """Converte as transcrições para formato markdown."""
+        if not self.info or not self.transcripts:
+            return "Nenhum conteúdo processado."
+        
+        md_lines = [
+            f"# {self.metadata['title']}",
+            f"\nCanal: {self.metadata['uploader']}",
+            f"Data: {self.metadata['upload_date']}\n",
+            "## Transcrições\n"
+        ]
+        
+        for transcript in self.transcripts:
+            video_url = f"https://www.youtube.com/watch?v={transcript['video_id']}"
+            md_lines.extend([
+                f"### Vídeo: {video_url}",
+                f"Idioma: {transcript['language']}\n",
+                transcript['content'],
+                "\n---\n"
+            ])
+        
+        return '\n'.join(md_lines)
+
+    def to_json(self) -> Dict:
+        """Retorna os dados em formato JSON."""
+        return {
+            'metadata': self.metadata,
+            'transcripts': self.transcripts
+        }

kb-processor/src/query_kb.py

@@ -0,0 +1,121 @@
+"""
+Script para consultar a base de conhecimento
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+import argparse
+from processors.embedding_processor import EmbeddingProcessor
+from processors.db_processor import DBProcessor
+from typing import List, Dict, Any
+import json
+import numpy as np
+
+class KnowledgeBaseQuery:
+    """Classe para consultar a base de conhecimento."""
+    
+    def __init__(self):
+        """Inicializa os processadores."""
+        self.db = DBProcessor()
+        self.embedding = EmbeddingProcessor()
+    
+    def search(self, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """
+        Pesquisa na base de conhecimento usando similaridade semântica.
+        
+        Args:
+            query (str): Pergunta ou texto para pesquisar
+            limit (int): Número máximo de resultados
+            
+        Returns:
+            List[Dict[str, Any]]: Lista de resultados ordenados por relevância
+        """
+        try:
+            # Gerar embedding da query
+            query_embedding = self.embedding.generate_embedding(query)
+            
+            # Conectar ao banco
+            self.db.connect()
+            
+            # Converter embedding para string de array PostgreSQL
+            embedding_str = '[' + ','.join(map(str, query_embedding)) + ']'
+            
+            # Buscar chunks mais similares
+            self.db.cur.execute("""
+                WITH similarity_scores AS (
+                    SELECT 
+                        e.id as embedding_id,
+                        e.chunk_text,
+                        d.title,
+                        d.metadata,
+                        d.file_path,
+                        1 - (e.embedding <#> %s) as similarity
+                    FROM embeddings e
+                    JOIN documents d ON e.document_id = d.id
+                    ORDER BY e.embedding <#> %s ASC
+                    LIMIT %s
+                )
+                SELECT 
+                    embedding_id,
+                    chunk_text,
+                    title,
+                    metadata,
+                    file_path,
+                    similarity
+                FROM similarity_scores
+                ORDER BY similarity DESC;
+            """, (embedding_str, embedding_str, limit))
+            
+            results = []
+            for row in self.db.cur.fetchall():
+                results.append({
+                    'embedding_id': row[0],
+                    'chunk_text': row[1],
+                    'title': row[2],
+                    'metadata': row[3],
+                    'file_path': row[4],
+                    'similarity': row[5]
+                })
+            
+            return results
+            
+        except Exception as e:
+            print(f"Erro ao pesquisar: {str(e)}")
+            return []
+        finally:
+            self.db.disconnect()
+    
+    def format_results(self, results: List[Dict[str, Any]]) -> str:
+        """Formata os resultados para exibição."""
+        if not results:
+            return "Nenhum resultado encontrado."
+        
+        output = []
+        for i, result in enumerate(results, 1):
+            similarity = result['similarity']
+            similarity_pct = similarity * 100  # Já está em percentagem
+            
+            output.append(f"\n--- Resultado {i} (Relevância: {similarity_pct:.1f}%) ---")
+            output.append(f"Título: {result['title']}")
+            output.append(f"Fonte: {result['file_path']}")
+            output.append("\nConteúdo Relevante:")
+            output.append(result['chunk_text'])
+            output.append("\nMetadados:")
+            output.append(json.dumps(result['metadata'], indent=2, ensure_ascii=False))
+            output.append("-" * 80)
+        
+        return "\n".join(output)
+
+def main():
+    """Função principal."""
+    parser = argparse.ArgumentParser(description='Consultar a base de conhecimento')
+    parser.add_argument('query', help='Pergunta ou texto para pesquisar')
+    parser.add_argument('--limit', type=int, default=5, help='Número máximo de resultados (padrão: 5)')
+    args = parser.parse_args()
+    
+    kb = KnowledgeBaseQuery()
+    results = kb.search(args.query, args.limit)
+    print(kb.format_results(results))
+
+if __name__ == "__main__":
+    main()

kb-processor/src/run_chatbot.py

@@ -0,0 +1,66 @@
+"""
+run_chatbot.py
+
+Author: Descomplicar® Crescimento Digital
+Link: https://descomplicar.pt
+Copyright: 2025 Descomplicar®
+"""
+
+"""
+Script para executar o chatbot AI integrado com Chatwoot.
+"""
+import os
+from flask import Flask, request, jsonify
+from processors.ai_chat_processor import AIChatProcessor
+
+app = Flask(__name__)
+
+# Configurações do Chatwoot
+CHATWOOT_API_KEY = os.getenv('CHATWOOT_API_KEY')
+CHATWOOT_ACCOUNT_ID = os.getenv('CHATWOOT_ACCOUNT_ID')
+CHATWOOT_BASE_URL = os.getenv('CHATWOOT_BASE_URL', 'https://app.chatwoot.com')
+
+# Inicializa processador
+chat_processor = AIChatProcessor(
+    chatwoot_api_key=CHATWOOT_API_KEY,
+    chatwoot_account_id=CHATWOOT_ACCOUNT_ID,
+    chatwoot_base_url=CHATWOOT_BASE_URL
+)
+
+@app.route('/webhook', methods=['POST'])
+def webhook():
+    """Endpoint para receber webhooks do Chatwoot."""
+    try:
+        data = request.json
+        
+        # Processa webhook
+        conversation_id = chat_processor.handle_webhook(data)
+        
+        if conversation_id:
+            return jsonify({
+                'status': 'success',
+                'conversation_id': conversation_id
+            })
+            
+        return jsonify({'status': 'ignored'})
+        
+    except Exception as e:
+        print(f"Erro ao processar webhook: {e}")
+        return jsonify({
+            'status': 'error',
+            'error': str(e)
+        }), 500
+
+if __name__ == '__main__':
+    # Verifica configurações
+    if not all([CHATWOOT_API_KEY, CHATWOOT_ACCOUNT_ID]):
+        print("Erro: Configurações do Chatwoot não encontradas!")
+        print("Configure as seguintes variáveis de ambiente:")
+        print("- CHATWOOT_API_KEY")
+        print("- CHATWOOT_ACCOUNT_ID")
+        print("- CHATWOOT_BASE_URL (opcional)")
+        exit(1)
+        
+    # Inicia servidor Flask
+    port = int(os.getenv('PORT', 5000))
+    app.run(host='0.0.0.0', port=port)

kb-processor/src/search.py

@@ -0,0 +1,34 @@
+"""
+Script para busca semântica na base de conhecimento
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+from processors.embedding_processor import EmbeddingProcessor
+
+def main():
+    """Função principal."""
+    try:
+        # Inicializar processador
+        embedding = EmbeddingProcessor()
+        
+        # Solicitar query do usuário
+        query = input("\nDigite sua pergunta: ")
+        
+        # Buscar documentos similares
+        print("\nBuscando documentos relevantes...")
+        results = embedding.search_similar(query, limit=5)
+        
+        # Mostrar resultados
+        print("\nResultados encontrados:")
+        print("-" * 80)
+        
+        for i, result in enumerate(results, 1):
+            print(f"\n{i}. {result['title']}")
+            print(f"Similaridade: {result['doc_similarity']:.1%}")
+            print("\nTrechos relevantes:")
+            print(result['relevant_chunks'])
+            print("-" * 80)
+
+if __name__ == "__main__":
+    main()

kb-processor/src/web/__init__.py

@@ -0,0 +1,11 @@
+"""
+__init__.py
+
+Author: Descomplicar® Crescimento Digital
+Link: https://descomplicar.pt
+Copyright: 2025 Descomplicar®
+"""
+
+"""
+Web Interface Package
+"""

kb-processor/src/web/app.py

@@ -0,0 +1,193 @@
+"""
+Web Interface - API Backend
+Descomplicar - Agência de Aceleração Digital
+https://www.descomplicar.pt
+"""
+
+import sys
+import os
+
+# Adicionar diretório src ao path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from fastapi import FastAPI, UploadFile, File, Form, WebSocket, Request, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from starlette.responses import FileResponse
+from typing import Optional
+import uvicorn
+import aiofiles
+from datetime import datetime
+from pydantic import BaseModel
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+import json
+from typing import Dict, List
+import asyncio
+
+from processors.web_processor import WebProcessor
+from processors.pdf_processor import PDFProcessor
+from processors.youtube_processor import YouTubeProcessor
+
+app = FastAPI(title="Processador de Documentos AI")
+
+# Configurar CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Montar diretório estático
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Montar diretório de uploads
+UPLOAD_DIR = "uploads"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+app.mount("/uploads", StaticFiles(directory=UPLOAD_DIR), name="uploads")
+
+# Configura templates e arquivos estáticos
+templates = Jinja2Templates(directory="templates")
+
+class ProcessResponse(BaseModel):
+    """Modelo de resposta do processamento."""
+    status: str
+    message: str
+    output_file: Optional[str] = None
+    metadata: Optional[dict] = None
+
+def get_processor(filepath: str):
+    """Determina o processador adequado baseado no tipo de arquivo."""
+    _, ext = os.path.splitext(filepath)
+    ext = ext.lower()
+    
+    if ext in ['.pdf']:
+        return PDFProcessor(filepath)
+    elif 'youtube.com/' in filepath or 'youtu.be/' in filepath:
+        return YouTubeProcessor(filepath)
+    elif filepath.startswith(('http://', 'https://')):
+        return WebProcessor(filepath)
+    else:
+        raise ValueError(f"Tipo de arquivo não suportado: {ext}")
+
+# Dicionário para armazenar o progresso de cada processamento
+progress_store: Dict[str, Dict[str, int]] = {}
+
+def update_progress(session_id: str, fase: str, progresso: int):
+    """Atualiza o progresso de um processamento."""
+    if session_id not in progress_store:
+        progress_store[session_id] = {}
+    progress_store[session_id][fase] = progresso
+
+@app.get("/", response_class=HTMLResponse)
+async def root(request: Request):
+    """Rota raiz - serve a página principal."""
+    return templates.TemplateResponse(
+        "index.html",
+        {"request": request}
+    )
+
+@app.websocket("/ws/{session_id}")
+async def websocket_endpoint(websocket: WebSocket, session_id: str):
+    await websocket.accept()
+    try:
+        while True:
+            if session_id in progress_store:
+                await websocket.send_json(progress_store[session_id])
+            await asyncio.sleep(0.1)  # Atualiza a cada 100ms
+    except:
+        pass
+
+@app.post("/process-url")
+async def process_url(request: Request):
+    """Processa uma URL."""
+    try:
+        # Lê o JSON do corpo da requisição
+        data = await request.json()
+        url = data.get("url")
+        if not url:
+            raise HTTPException(status_code=400, detail="URL não fornecida")
+        
+        # Gera um ID único para esta sessão
+        session_id = datetime.now().strftime("%Y%m%d%H%M%S")
+        
+        # Define função de callback
+        def update_progress(fase: str, progresso: int):
+            if session_id not in progress_store:
+                progress_store[session_id] = {}
+            progress_store[session_id][fase] = progresso
+        
+        # Criar processador
+        processor = get_processor(url)
+        if not processor:
+            raise HTTPException(status_code=400, detail="URL não suportada")
+        
+        # Processa o conteúdo
+        processor.process_content(progress_callback=update_progress)
+        
+        # Gerar nome do arquivo de saída
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_file = os.path.join(UPLOAD_DIR, f"output_{timestamp}.md")
+        
+        # Salvar conteúdo em Markdown
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(processor.to_markdown())
+        
+        # Preparar resposta
+        response = {
+            "status": "success",
+            "session_id": session_id,
+            "content": processor.read_content(),
+            "metadata": processor.metadata if hasattr(processor, "metadata") else {},
+            "markdown_file": os.path.basename(output_file)
+        }
+        
+        return response
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/process-file")
+async def process_file(file: UploadFile = File(...)):
+    """Processa um arquivo enviado."""
+    try:
+        # Salvar arquivo
+        file_path = os.path.join(UPLOAD_DIR, file.filename)
+        async with aiofiles.open(file_path, 'wb') as f:
+            content = await file.read()
+            await f.write(content)
+        
+        # Gera um ID único para esta sessão
+        session_id = datetime.now().strftime("%Y%m%d%H%M%S")
+        
+        # Criar processador
+        processor = get_processor(file_path)
+        
+        # Processar conteúdo
+        processor.process_content(progress_callback=lambda fase, prog: update_progress(session_id, fase, prog))
+        
+        # Gerar nome do arquivo de saída
+        name, _ = os.path.splitext(file.filename)
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_file = f"output/{name}_{timestamp}.md"
+        
+        # Salvar resultado
+        processor.save_markdown(output_file)
+        
+        return ProcessResponse(
+            status="success",
+            message="Arquivo processado com sucesso",
+            output_file=output_file,
+            metadata=processor.metadata
+        )
+        
+    except Exception as e:
+        return ProcessResponse(
+            status="error",
+            message=f"Erro ao processar arquivo: {str(e)}"
+        )
+
+if __name__ == "__main__":
+    uvicorn.run("app:app", host="0.0.0.0", port=8000, reload=True)

kb-processor/src/web/static/index.html

@@ -0,0 +1,158 @@
+<!DOCTYPE html>
+<html lang="pt">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Processador de Documentos AI - Descomplicar</title>
+    <link href="https://cdn.jsdelivr.net/npm/tailwindcss@2.2.19/dist/tailwind.min.css" rel="stylesheet">
+    <script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
+</head>
+<body class="bg-gray-100">
+    <div id="app" class="container mx-auto px-4 py-8">
+        <!-- Cabeçalho -->
+        <header class="text-center mb-12">
+            <h1 class="text-4xl font-bold text-gray-800 mb-2">Processador de Documentos AI</h1>
+            <p class="text-gray-600">Descomplicar - Agência de Aceleração Digital</p>
+        </header>
+
+        <!-- Área Principal -->
+        <main class="max-w-3xl mx-auto">
+            <!-- Tabs -->
+            <div class="flex mb-8">
+                <button 
+                    @click="activeTab = 'url'"
+                    :class="{'bg-blue-500 text-white': activeTab === 'url', 'bg-gray-200': activeTab !== 'url'}"
+                    class="flex-1 py-2 px-4 rounded-l-lg transition-colors">
+                    Processar URL
+                </button>
+                <button 
+                    @click="activeTab = 'file'"
+                    :class="{'bg-blue-500 text-white': activeTab === 'file', 'bg-gray-200': activeTab !== 'file'}"
+                    class="flex-1 py-2 px-4 rounded-r-lg transition-colors">
+                    Upload de Ficheiro
+                </button>
+            </div>
+
+            <!-- Formulário URL -->
+            <div v-if="activeTab === 'url'" class="bg-white p-6 rounded-lg shadow-md mb-8">
+                <form @submit.prevent="processUrl" class="space-y-4">
+                    <div>
+                        <label class="block text-gray-700 mb-2">URL para Processar</label>
+                        <input 
+                            v-model="url"
+                            type="url" 
+                            placeholder="https://exemplo.com"
+                            class="w-full p-2 border rounded focus:outline-none focus:ring-2 focus:ring-blue-500"
+                            required>
+                    </div>
+                    <button 
+                        type="submit"
+                        :disabled="processing"
+                        class="w-full bg-blue-500 text-white py-2 px-4 rounded hover:bg-blue-600 transition-colors disabled:opacity-50">
+                        {{ processing ? 'A Processar...' : 'Processar URL' }}
+                    </button>
+                </form>
+            </div>
+
+            <!-- Upload de Ficheiro -->
+            <div v-if="activeTab === 'file'" class="bg-white p-6 rounded-lg shadow-md mb-8">
+                <form @submit.prevent="processFile" class="space-y-4">
+                    <div>
+                        <label class="block text-gray-700 mb-2">Selecionar Ficheiro</label>
+                        <input 
+                            type="file"
+                            @change="handleFileChange"
+                            class="w-full p-2 border rounded focus:outline-none focus:ring-2 focus:ring-blue-500"
+                            required>
+                    </div>
+                    <button 
+                        type="submit"
+                        :disabled="processing || !selectedFile"
+                        class="w-full bg-blue-500 text-white py-2 px-4 rounded hover:bg-blue-600 transition-colors disabled:opacity-50">
+                        {{ processing ? 'A Processar...' : 'Processar Ficheiro' }}
+                    </button>
+                </form>
+            </div>
+
+            <!-- Resultado -->
+            <div v-if="result" :class="{'bg-green-100': result.status === 'success', 'bg-red-100': result.status === 'error'}" class="p-6 rounded-lg shadow-md">
+                <h3 class="font-bold mb-2">{{ result.status === 'success' ? 'Sucesso!' : 'Erro' }}</h3>
+                <p>{{ result.message }}</p>
+                <div v-if="result.output_file" class="mt-4">
+                    <a :href="result.output_file" target="_blank" class="text-blue-500 hover:underline">Ver Resultado</a>
+                </div>
+                <div v-if="result.metadata" class="mt-4">
+                    <h4 class="font-bold mb-2">Metadata:</h4>
+                    <pre class="bg-gray-50 p-2 rounded">{{ JSON.stringify(result.metadata, null, 2) }}</pre>
+                </div>
+            </div>
+        </main>
+    </div>
+
+    <script>
+        const { createApp } = Vue
+
+        createApp({
+            data() {
+                return {
+                    activeTab: 'url',
+                    url: '',
+                    selectedFile: null,
+                    processing: false,
+                    result: null
+                }
+            },
+            methods: {
+                async processUrl() {
+                    this.processing = true
+                    this.result = null
+                    
+                    try {
+                        const formData = new FormData()
+                        formData.append('url', this.url)
+                        
+                        const response = await axios.post('/process-url', formData)
+                        this.result = response.data
+                    } catch (error) {
+                        this.result = {
+                            status: 'error',
+                            message: error.response?.data?.message || 'Erro ao processar URL'
+                        }
+                    } finally {
+                        this.processing = false
+                    }
+                },
+                handleFileChange(event) {
+                    this.selectedFile = event.target.files[0]
+                },
+                async processFile() {
+                    if (!this.selectedFile) return
+                    
+                    this.processing = true
+                    this.result = null
+                    
+                    try {
+                        const formData = new FormData()
+                        formData.append('file', this.selectedFile)
+                        
+                        const response = await axios.post('/process-file', formData, {
+                            headers: {
+                                'Content-Type': 'multipart/form-data'
+                            }
+                        })
+                        this.result = response.data
+                    } catch (error) {
+                        this.result = {
+                            status: 'error',
+                            message: error.response?.data?.message || 'Erro ao processar ficheiro'
+                        }
+                    } finally {
+                        this.processing = false
+                    }
+                }
+            }
+        }).mount('#app')
+    </script>
+</body>
+</html>

kb-processor/src/web/templates/index.html

@@ -0,0 +1,300 @@
+<!DOCTYPE html>
+<html lang="pt">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Processador de Documentos AI</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet">
+    <style>
+        .progress {
+            margin-bottom: 10px;
+            height: 25px;
+        }
+        .progress-bar {
+            transition: width 0.3s ease-in-out;
+        }
+        #progressSection {
+            display: none;
+        }
+        .fase-label {
+            font-weight: bold;
+            margin-bottom: 5px;
+        }
+        .content-preview {
+            max-height: 500px;
+            overflow-y: auto;
+            padding: 15px;
+            background-color: #f8f9fa;
+            border-radius: 5px;
+            margin: 10px 0;
+            white-space: pre-wrap;
+            font-family: monospace;
+        }
+        .card {
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .btn-primary {
+            background-color: #0066cc;
+            border-color: #0066cc;
+        }
+        .btn-primary:hover {
+            background-color: #0052a3;
+            border-color: #0052a3;
+        }
+    </style>
+</head>
+<body class="bg-light">
+    <div class="container py-5">
+        <h1 class="text-center mb-4">Processador de Documentos AI</h1>
+        <h6 class="text-center text-muted mb-4">Descomplicar - Agência de Aceleração Digital</h6>
+
+        <div class="row justify-content-center">
+            <div class="col-md-8">
+                <ul class="nav nav-pills mb-4" role="tablist">
+                    <li class="nav-item flex-grow-1 text-center">
+                        <button class="nav-link active w-100" data-bs-toggle="pill" data-bs-target="#urlTab">Processar URL</button>
+                    </li>
+                    <li class="nav-item flex-grow-1 text-center">
+                        <button class="nav-link w-100" data-bs-toggle="pill" data-bs-target="#fileTab">Upload de Ficheiro</button>
+                    </li>
+                </ul>
+
+                <div class="tab-content">
+                    <!-- Tab URL -->
+                    <div class="tab-pane fade show active" id="urlTab">
+                        <form id="urlForm" class="mb-4">
+                            <div class="mb-3">
+                                <label for="urlInput" class="form-label">URL para Processar</label>
+                                <input type="url" class="form-control" id="urlInput" required>
+                            </div>
+                            <button type="submit" class="btn btn-primary w-100">Processar URL</button>
+                        </form>
+                    </div>
+
+                    <!-- Tab Ficheiro -->
+                    <div class="tab-pane fade" id="fileTab">
+                        <form id="fileForm" class="mb-4">
+                            <div class="mb-3">
+                                <label for="fileInput" class="form-label">Selecionar Ficheiro</label>
+                                <input type="file" class="form-control" id="fileInput" required>
+                            </div>
+                            <button type="submit" class="btn btn-primary w-100">Processar Ficheiro</button>
+                        </form>
+                    </div>
+                </div>
+
+                <!-- Seção de Progresso -->
+                <div id="progressSection" class="mt-4">
+                    <h4 class="mb-3">Progresso do Processamento</h4>
+                    
+                    <!-- Extração do ID -->
+                    <div class="fase-label">Extraindo ID do vídeo</div>
+                    <div class="progress">
+                        <div id="progress-extract_id" class="progress-bar" role="progressbar" style="width: 0%"></div>
+                    </div>
+
+                    <!-- Obtenção de Informações -->
+                    <div class="fase-label">Obtendo informações</div>
+                    <div class="progress">
+                        <div id="progress-get_info" class="progress-bar" role="progressbar" style="width: 0%"></div>
+                    </div>
+
+                    <!-- Processamento do Vídeo -->
+                    <div class="fase-label">Processando vídeo</div>
+                    <div class="progress">
+                        <div id="progress-process_video" class="progress-bar" role="progressbar" style="width: 0%"></div>
+                    </div>
+
+                    <!-- Obtenção da Transcrição -->
+                    <div class="fase-label">Obtendo transcrição</div>
+                    <div class="progress">
+                        <div id="progress-get_transcript" class="progress-bar" role="progressbar" style="width: 0%"></div>
+                    </div>
+
+                    <!-- Correção do Texto -->
+                    <div class="fase-label">Corrigindo texto</div>
+                    <div class="progress">
+                        <div id="progress-correct_text" class="progress-bar" role="progressbar" style="width: 0%"></div>
+                    </div>
+
+                    <!-- Atualização dos Metadados -->
+                    <div class="fase-label">Atualizando metadados</div>
+                    <div class="progress">
+                        <div id="progress-update_metadata" class="progress-bar" role="progressbar" style="width: 0%"></div>
+                    </div>
+                </div>
+
+                <!-- Resultado -->
+                <div id="result" class="mt-4"></div>
+
+                <!-- Erro -->
+                <div id="error" class="alert alert-danger mt-4" style="display: none;"></div>
+            </div>
+        </div>
+    </div>
+
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.bundle.min.js"></script>
+    <script>
+        let ws;
+        let sessionId;
+
+        async function processURL(url) {
+            try {
+                console.log('Processando URL:', url);
+                
+                // Mostra seção de progresso e reseta barras
+                document.getElementById('progressSection').style.display = 'block';
+                document.getElementById('error').style.display = 'none';
+                document.getElementById('result').innerHTML = '';
+                
+                document.querySelectorAll('.progress-bar').forEach(bar => {
+                    bar.style.width = '0%';
+                    bar.textContent = '';
+                });
+
+                // Envia requisição
+                const response = await fetch('/process-url', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ url: url })
+                });
+
+                console.log('Status da resposta:', response.status);
+                
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    console.error('Erro na resposta:', errorText);
+                    throw new Error(errorText);
+                }
+
+                const data = await response.json();
+                console.log('Dados recebidos:', data);
+                
+                // Conecta ao WebSocket
+                connectWebSocket(data.session_id);
+                
+                // Exibe o resultado
+                document.getElementById('result').innerHTML = `
+                    <div class="card">
+                        <div class="card-body">
+                            <h5 class="card-title">${data.metadata.title || 'Documento Processado'}</h5>
+                            <div class="card-text">
+                                <h6>Conteúdo:</h6>
+                                <div class="content-preview">${data.content || 'Sem conteúdo disponível'}</div>
+                                ${data.markdown_file ? `
+                                    <div class="mt-3">
+                                        <a href="/uploads/${data.markdown_file}" class="btn btn-primary" download>
+                                            Download Markdown
+                                        </a>
+                                    </div>
+                                ` : ''}
+                            </div>
+                        </div>
+                    </div>
+                `;
+            } catch (error) {
+                console.error('Erro ao processar:', error);
+                document.getElementById('error').textContent = `Erro: ${error.message}`;
+                document.getElementById('error').style.display = 'block';
+            }
+        }
+
+        function connectWebSocket(newSessionId) {
+            try {
+                sessionId = newSessionId;
+                const wsUrl = `ws://${window.location.host}/ws/${sessionId}`;
+                console.log('Conectando ao WebSocket:', wsUrl);
+                
+                ws = new WebSocket(wsUrl);
+                
+                ws.onopen = () => console.log('WebSocket conectado');
+                ws.onerror = (error) => console.error('Erro no WebSocket:', error);
+                
+                ws.onmessage = function(event) {
+                    console.log('Mensagem recebida:', event.data);
+                    const progress = JSON.parse(event.data);
+                    Object.entries(progress).forEach(([fase, valor]) => {
+                        const progressBar = document.getElementById(`progress-${fase}`);
+                        if (progressBar) {
+                            progressBar.style.width = `${valor}%`;
+                            progressBar.textContent = `${valor}%`;
+                        }
+                    });
+                };
+            } catch (error) {
+                console.error('Erro ao conectar WebSocket:', error);
+            }
+        }
+
+        // Event Listeners
+        document.getElementById('urlForm').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            console.log('Formulário submetido');
+            const url = document.getElementById('urlInput').value;
+            await processURL(url);
+        });
+
+        document.getElementById('fileForm').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            console.log('Formulário de arquivo submetido');
+            
+            const formData = new FormData();
+            const fileInput = document.getElementById('fileInput');
+            formData.append('file', fileInput.files[0]);
+
+            try {
+                document.getElementById('progressSection').style.display = 'block';
+                document.getElementById('error').style.display = 'none';
+                document.getElementById('result').innerHTML = '';
+                
+                document.querySelectorAll('.progress-bar').forEach(bar => {
+                    bar.style.width = '0%';
+                    bar.textContent = '';
+                });
+
+                const response = await fetch('/process-file', {
+                    method: 'POST',
+                    body: formData
+                });
+
+                console.log('Status da resposta do arquivo:', response.status);
+                
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    console.error('Erro no processamento do arquivo:', errorText);
+                    throw new Error(errorText);
+                }
+
+                const data = await response.json();
+                console.log('Dados do arquivo recebidos:', data);
+                connectWebSocket(data.session_id);
+                
+                document.getElementById('result').innerHTML = `
+                    <div class="card">
+                        <div class="card-body">
+                            <h5 class="card-title">${data.metadata.title || 'Arquivo Processado'}</h5>
+                            <div class="card-text">
+                                <h6>Conteúdo:</h6>
+                                <div class="content-preview">${data.content || 'Sem conteúdo disponível'}</div>
+                                ${data.markdown_file ? `
+                                    <div class="mt-3">
+                                        <a href="/uploads/${data.markdown_file}" class="btn btn-primary" download>
+                                            Download Markdown
+                                        </a>
+                                    </div>
+                                ` : ''}
+                            </div>
+                        </div>
+                    </div>
+                `;
+            } catch (error) {
+                console.error('Erro no upload:', error);
+                document.getElementById('error').textContent = `Erro: ${error.message}`;
+                document.getElementById('error').style.display = 'block';
+            }
+        });
+    </script>
+</body>
+</html>

kb-processor/src/web/uploads/notas2

@@ -0,0 +1,32 @@
+3jqeXUEWQFVxGE
+
+2025+CriarResultados!
+
+
+rsync -avz root@37.27.112.122:/var/lib/docker/volumes/ /var/lib/docker/volumes/
+
+
+help@descomplicar.pt
+tvdj9DN17HcL
+
+Igor Rosa
+igor@descomplicar.pt
+uQ4scvrQyda2+
+
+Filipe Faria
+filipe@aquisevende.pt
+HC2!MNt3Y4WRz
+
+Helder Faria
+helder@aquisevende.pt
+uQE4pE8+lEHws
+
+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
+
+
+comercial@aquisevende.pt
+hhiOlPZh4uz4
+
+
+marketing@aquisevende.pt
+8N_KiF2Y!

kb-processor/src/web/uploads/output_20250107_230033.md

@@ -0,0 +1,101 @@
+# NEW Deepseek-V3 Computer Use AI Agents are INSANE (FREE!) 🤯
+
+Canal: Julian Goldie SEO
+Data: 20250107
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=K0qlaCIle1Y
+Idioma: English (auto-generated)
+
+# Como Utilizar o Browser Use Web UI: Um Guia Completo
+
+Hoje, vou mostrar exatamente como utilizar o **Browser Use Web UI**, um poderoso agente de IA que pode ser configurado gratuitamente diretamente no seu navegador. Este agente é capaz de realizar praticamente qualquer tarefa que lhe seja solicitada. A configuração é bastante simples, e vou demonstrar como fazê-la em instantes. O que irá ver hoje surpreendeu-me bastante.
+
+## Configuração do Agente
+
+No Browser Use Web UI, pode selecionar o tipo de agente. Por exemplo, pode optar pela opção **Custom** e atribuir múltiplas tarefas para o agente completar. Além disso, pode escolher utilizar ou não a função de **visão**, o que significa que o agente pode ou não "ver" o ecrã do seu computador. Se desativar esta função, poderá selecionar entre diferentes APIs, como a **DeepSeek Versão 3**.
+
+### Utilizando a API DeepSeek
+
+Para utilizar a API da DeepSeek, basta selecioná-la e inserir a sua chave de API diretamente no campo indicado. Também pode escolher entre utilizar o seu próprio navegador ou o navegador integrado ao Web UI. A DeepSeek é uma opção extremamente acessível — por exemplo, com um saldo de 10 USD, gastei apenas 2 cêntimos numa semana de utilização.
+
+### Configurações Adicionais
+
+Nas configurações, pode decidir se deseja utilizar o seu próprio navegador ou o navegador do Web UI. Além disso, é possível ajustar a largura e altura do navegador e até mesmo guardar sessões de gravação. Isto significa que, enquanto o agente de IA utiliza o navegador, pode gravar todo o ecrã, criando uma espécie de screencast.
+
+## Execução de Tarefas
+
+Vamos testar o agente com uma tarefa simples: **"Vá para o Google, pesquise por 'OpenAI' e traga-me o primeiro URL"**. Ao executar esta tarefa, o agente navega até ao Google, digita "OpenAI", clica em pesquisar e retorna o primeiro URL encontrado. Tudo isto é feito sem qualquer intervenção manual — as minhas mãos estão completamente fora do teclado!
+
+### Gravação e Análise de Resultados
+
+Após a execução, pode reproduzir a gravação do ecrã para ver exatamente o que o agente fez. Isto é particularmente útil para criar tutoriais ou demonstrações. Além disso, o agente fornece um relatório detalhado, incluindo o URL copiado, informações sobre erros e o processo de pensamento do modelo.
+
+## Exploração de Funcionalidades Avançadas
+
+Vamos tentar algo mais complexo: **"Vá para o Google, pesquise por 'melhor agência de SEO no Japão' e crie um esboço de conteúdo com base nos concorrentes"**. O agente navega até ao Google, digita a palavra-chave e analisa os resultados. Em seguida, cria um esboço de conteúdo em markdown, listando as principais agências de SEO no Japão e fornecendo uma breve descrição de cada uma.
+
+### Comparação com Outros Agentes
+
+Uma das vantagens do Browser Use Web UI é a sua capacidade de seguir múltiplos passos sem falhar. Em comparação com outros agentes, como o **Claude Computer Agent**, que tende a falhar após alguns passos, o Browser Use Web UI demonstra ser muito mais competente em tarefas complexas.
+
+## Conclusão
+
+O Browser Use Web UI é uma ferramenta incrivelmente poderosa para automatizar tarefas no navegador. Seja para pesquisas simples ou análises complexas, oferece uma flexibilidade e eficiência impressionantes. E o melhor de tudo: é fácil de configurar e extremamente acessível.
+
+Se quiser seguir este guia passo a passo, consulte as instruções no [GitHub do Browser Use Web UI](https://github.com/browseruse/webui). Lá, encontrará todas as notas do vídeo, juntamente com os meus melhores prompts e dicas para configurar o agente.
+
+---
+
+**Nota:** Se encontrar problemas durante a configuração, pode colar os erros no terminal ou em ferramentas como o **Claw** para obter instruções detalhadas sobre como corrigi-los.
+
+# Como Escolher a Agência de SEO Certa e o Impacto da IA no Mercado
+
+## Introdução
+Escolher a agência de SEO certa pode ser um desafio, especialmente quando se trata de avaliar a qualidade dos serviços oferecidos. No entanto, com o avanço da inteligência artificial (IA), muitas tarefas que antes exigiam assistentes humanos agora podem ser realizadas por agentes de IA. Vamos explorar como isso está a transformar o mercado e o que você precisa saber para se manter à frente.
+
+## A Evolução dos Agentes de IA
+Atualmente, os agentes de IA estão a tornar-se cada vez mais sofisticados, graças ao uso de APIs avançadas, como DeepSeek versão 3 e Gemini Flash Experimental. Estas tecnologias permitem que os agentes de IA produzam resultados muito melhores em comparação com ferramentas mais antigas, como o CLA Computer, que não recebe atualizações há meses.
+
+### Exemplo Prático
+Imagine que precisa encontrar os voos mais baratos de Bangkok para o Reino Unido. Com um agente de IA, pode simplesmente pedir: "Encontre os voos mais baratos de Bangkok para o Reino Unido". O agente retornará com uma análise detalhada, como:
+
+- **Voo mais barato**: 23.000 baht
+- **Data de partida**: 12 de maio
+- **Data de retorno**: 25 de maio
+- **Tempo total de viagem**: 19 horas e 50 minutos
+- **Companhias aéreas**: Shanghai Airlines e China Eastern
+
+Isso é mais rápido e eficiente do que contratar um assistente humano para realizar a mesma tarefa.
+
+## O Impacto da IA no Mercado de Trabalho
+A IA está a substituir muitas funções que antes exigiam assistentes humanos, especialmente tarefas administrativas básicas. Estes agentes de IA são gratuitos e só irão melhorar com o tempo. Grandes empresas como ChatGPT, Claude e Google estão prestes a lançar os seus próprios agentes de IA, o que deve acontecer nos próximos meses.
+
+### Economia de Custos
+Se tem a opção entre contratar um assistente virtual por $5 a $15 por hora ou usar um agente de IA, a escolha é clara. Para empresas e profissionais que utilizam assistência executiva, a IA é uma solução mais económica e eficiente.
+
+## A Importância de Experimentar com IA
+Mesmo que os agentes de IA ainda não sejam perfeitos, é crucial começar a experimentar com estas tecnologias. Nos últimos 12 a 24 meses, muitas empresas deixaram de contratar redatores humanos, fotógrafos e editores, optando por soluções de IA como o Dript para edição de vídeos.
+
+### Exemplo de Codificação
+Até mesmo a área de desenvolvimento de software está a ser impactada. Ferramentas como o Bolt DIY permitem que crie ferramentas SAS em minutos, sem custo algum. Isso elimina a necessidade de contratar desenvolvedores front-end, por exemplo.
+
+## Conclusão
+A IA está a transformar rapidamente o mercado de trabalho e a maneira como realizamos tarefas cotidianas. Para se manter competitivo, é essencial entender onde a indústria está a ir e quais empregos ainda serão necessários no futuro.
+
+### Recursos Adicionais
+Se quiser aprender mais sobre como configurar e utilizar agentes de IA, confira o meu curso gratuito de SEO. Ele inclui:
+
+- **53 ferramentas de SEO**
+- **Tutoriais passo a passo**
+- **Dicas e modelos**
+- **Uma comunidade de 3.000 profissionais de SEO**
+
+Além disso, pode agendar uma sessão gratuita de estratégia de SEO para aprender como aumentar o tráfego do seu site e gerar vendas de forma automática.
+
+**Link para o curso e recursos adicionais estão na descrição do vídeo.**
+
+Obrigado por assistir e nos vemos no próximo vídeo!
+
+---

kb-processor/src/web/uploads/output_20250107_230159.md

@@ -0,0 +1,104 @@
+# NEW Deepseek-V3 Computer Use AI Agents are INSANE (FREE!) 🤯
+
+Canal: Julian Goldie SEO
+Data: 20250107
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=K0qlaCIle1Y
+Idioma: English (auto-generated)
+
+# Como Utilizar o Browser Use Web UI: Um Poderoso Agente de IA para o Seu Browser
+
+Hoje, vou mostrar-lhe exatamente como utilizar o **Browser Use Web UI**, um poderoso agente de IA que pode configurar gratuitamente diretamente no seu browser. Este agente de IA pode executar tarefas com base nas suas instruções, e vou guiá-lo através do processo de configuração e de algumas das suas funcionalidades mais impressionantes.
+
+## Configuração do Browser Use Web UI
+
+O processo de configuração é simples. Eis como pode começar:
+
+1. Visite a **página do GitHub do Browser Use Web UI** e siga as instruções fornecidas.
+2. Certifique-se de que tem o **Python 3.1 ou superior** instalado no seu sistema.
+3. Copie e cole as instruções do terminal passo a passo para configurar a ferramenta localmente.
+
+Se encontrar algum problema durante a configuração, pode resolver problemas colando as mensagens de erro no **Claw** ou noutras ferramentas de depuração. Uma vez configurado, poderá hospedar a ferramenta localmente e começar a utilizá-la.
+
+## Configuração do Agente de IA
+
+Assim que a ferramenta estiver configurada, pode configurar o agente de IA de acordo com as suas necessidades:
+
+- **Tipo de Agente**: Selecione **Custom** para definir tarefas específicas.
+- **Passos**: Escolha o número máximo de passos que o agente pode dar para completar uma tarefa (o padrão é 100).
+- **Visão**: Decida se a IA pode ver o seu ecrã ou não. Se estiver a utilizar o **DeepSeek Versão 3**, note que este não suporta visão.
+- **Seleção de API**: Pode integrar APIs como o **DeepSeek** inserindo a sua chave de API. O DeepSeek é uma opção acessível, custando apenas 2 cêntimos por utilização.
+
+Para obter uma chave de API do DeepSeek, visite [deepseek.com](https://deepseek.com). Assim que tiver a chave, insira-a nas definições do Browser Use Web UI e selecione o nome do modelo (por exemplo, **DeepSeek Hi from Chat**).
+
+## Utilização do Agente de IA
+
+O agente de IA pode interagir com o seu browser ou utilizar o seu próprio browser. Também pode ajustar definições como a largura e altura do browser. Uma funcionalidade destacada é a capacidade de **gravar sessões**, permitindo-lhe capturar as ações da IA como um screencast.
+
+### Exemplo de Tarefa: Pesquisar no Google
+
+Vamos testar o agente com uma tarefa simples:
+
+1. **Tarefa**: Ir ao Google.com, digitar "OpenAI", clicar em pesquisar e recuperar o primeiro URL.
+2. **Executar o Agente**: Observe como a IA navega até ao Google, digita a consulta e extrai o URL.
+
+Pode rever a gravação para ver como a IA analisou a página e completou a tarefa. Esta funcionalidade é particularmente útil para criar tutoriais ou demonstrações.
+
+### Tarefa Avançada: Investigação de SEO
+
+Para uma tarefa mais complexa, vamos tentar uma investigação de SEO:
+
+1. **Tarefa**: Ir ao Google, pesquisar por "Melhor Agência de SEO Japão" e criar um esboço de conteúdo com base na análise da concorrência.
+2. **Executar o Agente**: Observe como a IA navega pelo Google, analisa os resultados da pesquisa e gera um esboço de conteúdo formatado em markdown.
+
+A IA identificou as principais agências de SEO no Japão e forneceu uma visão detalhada de cada uma, demonstrando a sua capacidade de lidar com tarefas de múltiplos passos de forma eficaz.
+
+## Observações Chave
+
+- **Desempenho**: O Browser Use Web UI supera outras ferramentas como o **Claude Computer Agent** na execução de tarefas complexas e de múltiplos passos.
+- **Flexibilidade**: Pode personalizar o comportamento do agente, integrar APIs e gravar sessões para revisão posterior.
+- **Custo-Efetividade**: A utilização de APIs como o DeepSeek é incrivelmente acessível, tornando esta ferramenta viável para vários casos de utilização.
+
+## Conclusão
+
+O Browser Use Web UI é uma ferramenta versátil e poderosa para automatizar tarefas baseadas no browser. Quer esteja a conduzir investigações, a criar conteúdo ou a testar fluxos de trabalho, este agente de IA pode poupar-lhe tempo e esforço. Experimente e explore todo o seu potencial!
+
+Para mais detalhes, visite a [página do GitHub do Browser Use Web UI](https://github.com/browser-use/webui) e siga as instruções de configuração. Boa automatização!
+
+# Como Escolher a Agência de SEO Certa e o Impacto da IA no Mercado
+
+## Introdução
+Escolher a agência de SEO certa pode ser um desafio, especialmente quando se trata de identificar os serviços-chave que elas oferecem. Recentemente, fiz uma pesquisa detalhada sobre o assunto e decidi partilhar as minhas descobertas. Além disso, vou abordar como a inteligência artificial (IA) está a transformar o mercado de trabalho, especialmente em tarefas administrativas e criativas.
+
+## A Evolução das Ferramentas de IA
+Ao utilizar as APIs mais recentes, como a DeepSeek versão 3 ou a Gemini Flash Experimental, é possível obter resultados muito mais precisos e eficientes. Em contraste, ferramentas mais antigas, como o CLA Computer, que não são atualizadas há meses, não oferecem o mesmo nível de desempenho.
+
+### Testar a IA em Tarefas Práticas
+Para ilustrar, pedi ao sistema para encontrar os voos mais baratos de Banguecoque para o Reino Unido. O resultado foi impressionante: o voo mais barato encontrado foi para Londres, custando 23.000, com partida a 12 de maio e regresso a 25 de maio, com uma escala e tempo total de viagem de 19 horas e 50 minutos. A companhia aérea era a Shanghai Airlines e a China Eastern.
+
+## O Impacto da IA no Mercado de Trabalho
+A IA está a revolucionar o mercado de trabalho, especialmente em tarefas administrativas básicas. Imagine um assistente virtual que pode realizar essas tarefas de forma mais rápida e barata do que um humano. Estes agentes de IA estão apenas no início da sua evolução e só vão melhorar com o tempo.
+
+### Exemplos Práticos
+Nos últimos 12 a 24 meses, desde que comecei a usar o ChatGPT, praticamente não contratamos mais redatores humanos ou fotógrafos. Todo o conteúdo do meu canal principal de IA é editado usando ferramentas como o Dript, sem intervenção humana. Isto está a acontecer em tempo real e é crucial experimentar estas tecnologias, mesmo que não sejam perfeitas, porque estão a mudar o mundo.
+
+## O Futuro do Desenvolvimento de Software
+Até mesmo no desenvolvimento de software, a IA está a fazer a diferença. Hoje, posso criar qualquer ferramenta ou software como serviço (SaaS) em questão de minutos usando plataformas como o Bolt DIY, sem custo algum e de forma muito mais rápida. Isto é especialmente relevante para programadores front-end, cuja procura pode diminuir significativamente.
+
+## Conclusão
+A IA está a transformar rapidamente o mercado de trabalho e a maneira como realizamos tarefas quotidianas. É essencial entender para onde a indústria está a ir e quais empregos ainda serão necessários no futuro. Experimentar estas tecnologias agora pode proporcionar uma vantagem competitiva significativa.
+
+## Recursos Adicionais
+Se quiser aprender mais sobre como configurar e utilizar estas ferramentas de IA, confira o meu curso gratuito de SEO. Nele, encontrará:
+- Lições passo a passo sobre SEO
+- Dicas e modelos de SEO
+- 53 ferramentas de SEO
+- Uma comunidade de mais de 3.000 especialistas em SEO prontos para ajudar
+
+Além disso, pode agendar uma sessão gratuita de estratégia de SEO para aprender como aumentar o tráfego do seu site e gerar vendas de forma automática.
+
+Obrigado por assistir e vemo-nos no próximo vídeo!
+
+---

kb-processor/src/web/uploads/output_20250107_230330.md

@@ -0,0 +1,99 @@
+# NEW Deepseek-V3 Computer Use AI Agents are INSANE (FREE!) 🤯
+
+Canal: Julian Goldie SEO
+Data: 20250107
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=K0qlaCIle1Y
+Idioma: English (auto-generated)
+
+# Como Utilizar o Browser Use Web UI: Um Guia Completo
+
+Hoje, vou mostrar exatamente como utilizar o **Browser Use Web UI**, um poderoso agente de IA que pode ser configurado gratuitamente diretamente no seu navegador. Este agente é capaz de realizar qualquer tarefa que lhe for solicitada. A configuração é extremamente simples, e vou demonstrar como fazê-lo em poucos instantes. O que irá ver hoje deixou-me verdadeiramente impressionado.
+
+## Configuração do Agente
+
+Ao configurar o agente, pode selecionar o tipo de agente e escolher a opção **Custom**. Isto permite-lhe atribuir múltiplas tarefas para o agente completar. Além disso, pode optar por utilizar ou não a funcionalidade de **visão**, o que significa que a IA pode ou não ver o seu ecrã. Se desativar esta opção, poderá escolher entre várias APIs diferentes.
+
+É aqui que entra a **DeepSeek Versão 3**. Pode selecionar a DeepSeek como a API e inserir a sua chave de API diretamente. Também é possível escolher entre utilizar o seu próprio navegador ou um navegador fornecido pelo WebUI. Pode atribuir tarefas ao agente e acompanhar o processo em tempo real.
+
+## Configuração Inicial
+
+Para configurar o Browser Use Web UI, siga as instruções disponíveis no GitHub. Irá precisar de ter o **Python 3.1** ou superior instalado. Depois, basta copiar e colar cada instrução no terminal. Se encontrar problemas durante a configuração, pode colar os erros no terminal para obter instruções sobre como corrigi-los.
+
+## Utilizando a DeepSeek API
+
+Se optar por utilizar a **DeepSeek Versão 3**, note que esta versão não possui funcionalidade de visão. Para obter uma chave de API da DeepSeek, visite o site [deepseek.com](https://deepseek.com). A API é extremamente acessível; por exemplo, um saldo de $10 pode durar semanas, com custos mensais ridiculamente baixos.
+
+Depois de criar uma nova chave de API, insira-a no Browser Use Web UI e selecione o nome do modelo. Se estiver a utilizar a DeepSeek Versão 3, digite **deepseek-chat** no campo do nome do modelo.
+
+## Execução de Tarefas
+
+Dentro das configurações, pode decidir se deseja utilizar o seu próprio navegador ou o navegador do Browser Use Web UI. Também pode ajustar a largura e altura do navegador e salvar sessões de gravação. Por exemplo, quando o agente de IA está a utilizar o seu navegador, pode gravar o ecrã inteiro, criando uma espécie de screencast.
+
+Vamos testar uma tarefa padrão: **"Vá para google.com, digite OpenAI, clique em pesquisar e dê-me a primeira URL"**. Ao executar o agente, ele navega até ao Google, digita "OpenAI", clica em pesquisar e retorna a primeira URL. O agente analisa a página utilizando visão e seleciona diferentes partes da página.
+
+## Gravação e Análise de Resultados
+
+Pode reproduzir a gravação do ecrã para ver exatamente o que o agente fez. Isto pode ser útil para criar vídeos explicativos, onde uma voz de IA narra o processo enquanto o agente executa as tarefas no ecrã.
+
+Na secção de gravação, verá o resultado final, incluindo a URL copiada do Google, informações sobre erros e o processo de pensamento do modelo. Isto permite-lhe compreender como o agente chegou ao resultado.
+
+## Testando Limites
+
+Vamos tentar algo mais complexo: **"Vá para google.com, digite 'melhor agência de SEO no Japão', e dê-me um esboço de conteúdo baseado nos meus concorrentes para SEO"**. O agente navega até ao Google, digita a palavra-chave e analisa os resultados. Ele cria um esboço de conteúdo em markdown, listando as principais agências de SEO no Japão e fornecendo uma breve visão geral de cada uma.
+
+## Conclusão
+
+O **Browser Use Web UI** é uma ferramenta incrivelmente poderosa que pode realizar tarefas complexas de forma autónoma. É muito mais competente do que outros agentes de IA, como o Claude Computer Agent, que tende a falhar após algumas etapas. Com o Browser Use Web UI, pode executar ações mais complexas e obter resultados detalhados.
+
+Se está interessado em automatizar tarefas no navegador, esta ferramenta é definitivamente vale a pena explorar.
+
+# Como Escolher a Agência de SEO Certa e o Futuro dos Assistentes Virtuais
+
+## A Força dos Serviços de SEO
+
+Escolher a agência de SEO certa é crucial para o sucesso online. Uma agência que destaca os seus pontos fortes e serviços-chave de SEO pode fazer toda a diferença. É interessante observar como algumas agências já realizaram a pesquisa necessária e, com base nisso, começaram a criar análises de conteúdo.
+
+## Utilizando APIs Modernas para Melhores Resultados
+
+Uma das vantagens de utilizar as APIs mais recentes, como o DeepSeek versão 3 ou o Gemini Flash Experimental, é que pode obter resultados muito melhores. Por exemplo, se estiver a utilizar algo como o CLA Computer, que não foi atualizado há meses, não terá o mesmo nível de eficiência.
+
+## Desafios com Navegadores Pessoais
+
+Tentei utilizar o meu próprio navegador, mas não funcionou como esperado. Mesmo após ajustar as configurações, continuei a encontrar erros. Parece que, ao utilizar um navegador, não há garantia de que tudo funcionará perfeitamente.
+
+## A Evolução dos Agentes de IA
+
+A capacidade de realizar tarefas básicas de administração, como clicar em botões, pode agora ser substituída por IA. Estes agentes de IA são gratuitos e só vão melhorar com o tempo. Empresas como a ChatGPT, Claude e Google provavelmente lançarão os seus próprios agentes em breve.
+
+## Escolhendo entre IA e Assistentes Virtuais
+
+Se tiver a opção entre utilizar um agente de IA ou contratar um assistente virtual que custa $5 por hora, a escolha é clara. Para empresas ou pessoas que utilizam assistência executiva, a IA é a opção mais sensata.
+
+## O Impacto da IA em Diferentes Profissões
+
+Nos últimos 12 a 24 meses, desde que começámos a utilizar o ChatGPT, não contratámos mais redatores humanos ou fotógrafos. Todo o conteúdo do meu canal principal de IA é editado com ferramentas como o Dript, sem intervenção humana. Isto está a acontecer em tempo real e é crucial experimentar estas tecnologias, mesmo que não sejam perfeitas.
+
+## Exemplo Prático: Encontrar Voos Baratos
+
+Vamos dar uma olhada a um exemplo prático. Pedi ao agente de IA para encontrar o voo mais barato de Bangkok para o Reino Unido. Ele encontrou um voo para Londres por 23.000, partindo a 12 de maio e regressando a 25 de maio, com uma escala e um tempo total de viagem de 19 horas e 50 minutos. Este tipo de análise detalhada é mais rápida e eficiente do que utilizar um assistente humano.
+
+## O Futuro da IA
+
+Daqui a seis meses ou um ano, o mundo pode parecer muito diferente. A IA está a evoluir rapidamente e é importante estar preparado para estas mudanças. Se quiser aprender mais sobre como configurar e utilizar estas ferramentas, confira o meu curso gratuito de SEO.
+
+## Recursos Adicionais
+
+No curso, irá encontrar:
+- Lições passo a passo sobre SEO
+- Dicas e modelos de SEO
+- 53 ferramentas de SEO
+- Uma comunidade de 3.000 especialistas em SEO prontos para ajudar
+
+Além disso, pode agendar uma sessão gratuita de estratégia de SEO para aprender como aumentar o tráfego do seu site e gerar vendas de forma automática. Nesta sessão, irá aprender as melhores estratégias de link building e como superar a concorrência.
+
+Obrigado por assistir! Vejo-o no próximo vídeo.
+
+---

kb-processor/src/web/uploads/output_20250107_230505.md

@@ -0,0 +1,96 @@
+# NEW Deepseek-V3 Computer Use AI Agents are INSANE (FREE!) 🤯
+
+Canal: Julian Goldie SEO
+Data: 20250107
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=K0qlaCIle1Y
+Idioma: English (auto-generated)
+
+# Como Utilizar o Browser Use Web UI: Um Guia Completo
+
+Hoje vou mostrar exatamente como utilizar o **Browser Use Web UI**, um poderoso agente de IA que pode ser configurado gratuitamente diretamente no seu navegador. Este agente é capaz de realizar qualquer tarefa que lhe seja atribuída. A configuração é simples e vou demonstrar como fazê-la em instantes. O que irá ver hoje deixou-me verdadeiramente surpreendido!
+
+## Configuração Inicial
+
+Ao configurar o agente, pode selecionar o tipo de agente como **Custom** e definir múltiplas etapas para completar uma ação. Além disso, pode optar por utilizar ou não a funcionalidade de **visão**, o que significa que a IA pode ou não ver o seu ecrã. Se desativar esta opção, poderá escolher entre várias APIs diferentes.
+
+É aqui que entra o **DeepSeek Versão 3**. Pode selecionar o DeepSeek como a API e inserir a sua chave de API diretamente. Também é possível optar por utilizar o seu próprio navegador ou um navegador fornecido pelo WebUI.
+
+## Tarefas e Funcionalidades
+
+Pode atribuir tarefas ao agente e acompanhar o processo em tempo real. Vou mostrar algumas das melhores tarefas que pode programar hoje. É impressionante o que se pode fazer com esta ferramenta.
+
+### Configuração Prática
+
+Para configurar o Browser Use Web UI, siga as instruções no GitHub. Irá precisar de ter o **Python 3.1** ou superior instalado. Depois, vá para o terminal, copie cada instrução e configure o ambiente. Se encontrar problemas, basta colar os erros no terminal para obter instruções sobre como corrigi-los.
+
+## Utilizando a API DeepSeek
+
+Se estiver a utilizar o **DeepSeek Versão 3**, não precisará da funcionalidade de visão. Basta selecionar o DeepSeek como a API e inserir a chave de API. O custo do DeepSeek é extremamente baixo. Por exemplo, com um saldo de $10, pode utilizar a API durante semanas com um custo mínimo.
+
+### Criando uma Chave de API
+
+Crie uma nova chave de API no site do DeepSeek e insira-a no Browser Use Web UI. Selecione o nome do modelo, como **DeepSeek Hi from Chat**, e está pronto! Agora tem a API configurada e pronta para uso.
+
+## Configurações Avançadas
+
+Nas configurações, pode decidir se deseja utilizar o seu próprio navegador ou o navegador do Browser Use Web UI. Também pode ajustar a largura e altura do navegador e salvar sessões de gravação. Isto permite que grave o ecrã enquanto o agente de IA utiliza o navegador, criando uma espécie de screencast.
+
+### Testando o Agente
+
+Vamos testar o agente com uma tarefa simples: ir para o Google, digitar "OpenAI", clicar em pesquisar e retornar o primeiro URL. Ao executar o agente, ele navega até ao Google, digita "OpenAI" e retorna o primeiro URL. Pode ver o processo de análise da página e a gravação do ecrã.
+
+## Gravações e Análises
+
+Na secção de gravações, pode reproduzir o que aconteceu durante a execução da tarefa. Isto é útil para criar vídeos explicativos, onde uma voz de IA pode narrar o processo enquanto interage com o ecrã.
+
+### Exemplo de Utilização Prática
+
+Vamos tentar algo mais complexo: pesquisar no Google por "melhor agência de SEO no Japão" e criar um esboço de conteúdo com base nos concorrentes. O agente navega até ao Google, digita a palavra-chave e analisa os resultados. Ele cria um esboço em markdown, listando as principais agências de SEO no Japão e fornecendo uma visão geral de cada uma.
+
+## Conclusão
+
+O **Browser Use Web UI** é uma ferramenta poderosa e versátil. Pode realizar tarefas complexas de forma autónoma, analisar páginas da web e gerar conteúdo útil. Comparado com outras ferramentas, como o Claude Computer Agent, mostra-se mais competente e capaz de seguir mais etapas sem falhas.
+
+Se está à procura de uma forma eficiente de automatizar tarefas na web, o Browser Use Web UI é uma excelente opção. Experimente e veja como pode transformar o seu fluxo de trabalho!
+
+# Como Escolher a Agência de SEO Certa e o Impacto da IA no Mercado
+
+## Introdução
+Escolher a agência de SEO certa é crucial para o sucesso de qualquer estratégia digital. Uma agência que destaca os seus pontos fortes e serviços-chave pode fazer toda a diferença. Recentemente, realizei uma pesquisa detalhada sobre o assunto e decidi partilhar as minhas descobertas.
+
+## A Evolução das Ferramentas de IA
+Ao analisar o conteúdo, percebi como as ferramentas de IA estão a evoluir rapidamente. Por exemplo, ao utilizar APIs mais recentes, como o DeepSeek versão 3 ou o Gemini Flash Experimental, é possível obter resultados muito melhores. Em contraste, ferramentas como o CLA Computer, que não são atualizadas há meses, não oferecem o mesmo nível de desempenho.
+
+### Testar a IA em Tarefas Práticas
+Decidi testar a eficácia dessas ferramentas em tarefas práticas. Por exemplo, pedi ao Google para encontrar os voos mais baratos de Banguecoque para o Reino Unido. O resultado foi impressionante: o voo mais barato encontrado foi para Londres, custando 23.000, com partida a 12 de maio e regresso a 25 de maio, com uma paragem e tempo total de viagem de 19 horas e 50 minutos. A companhia aérea era a Shanghai Airlines e a China Eastern.
+
+## A Substituição de Tarefas por IA
+Estas ferramentas estão a substituir tarefas que antes exigiam assistentes humanos. Tarefas administrativas básicas, como clicar em botões, podem agora ser realizadas por IA. E o mais impressionante é que estas ferramentas só vão melhorar com o tempo. Empresas como a ChatGPT, Claude e Google estão prestes a lançar os seus próprios agentes de IA, o que deverá acontecer nos próximos meses.
+
+### Comparação entre IA e Assistência Humana
+Se tiver a opção entre usar um agente de IA ou contratar um assistente virtual que custa $5 por hora, a escolha é clara. Para empresas ou pessoas que utilizam assistência executiva, a IA é uma opção mais económica e eficiente.
+
+## O Impacto da IA em Diferentes Setores
+Nos últimos 12 a 24 meses, desde que comecei a usar o ChatGPT, percebi que já não precisamos de contratar redatores humanos, fotógrafos ou editores. Toda a edição do meu canal principal de IA é feita com ferramentas como o Dript, sem intervenção humana. Isto está a acontecer em tempo real e é crucial experimentar estas ferramentas, mesmo que não sejam perfeitas, porque estão a mudar o mundo.
+
+### Exemplo Prático: Desenvolvimento de Software
+Até mesmo para desenvolvimento de software, já não contrataria um desenvolvedor front-end. Posso criar qualquer ferramenta ou software SAS em minutos usando algo como o Bolt DIY, sem custo algum e de forma muito mais rápida.
+
+## Conclusão
+É essencial entender para onde a indústria está a ir e quais empregos ainda serão necessários. A IA está a revolucionar o mercado e é importante adaptar-se a estas mudanças. Se quiser aprender mais sobre como configurar estas ferramentas e obter acesso a 50 casos de uso e prompts práticos, confira o meu curso gratuito de SEO.
+
+### Recursos Adicionais
+No curso, encontrará:
+- Lições passo a passo sobre SEO
+- Dicas e modelos de SEO
+- 53 ferramentas de SEO
+- Uma comunidade de 3.000 especialistas em SEO para ajudar com qualquer dúvida
+
+Além disso, se quiser uma sessão gratuita de estratégia de SEO, mostramos como levamos sites de 0 a 145.000 visitas por mês e geramos centenas de milhares de dólares em vendas no piloto automático. Sinta-se à vontade para agendar uma sessão e aprender as melhores estratégias de construção de links e como aumentar o tráfego SEO em 10x.
+
+Obrigado por assistir e vemo-nos no próximo vídeo!
+
+---

kb-processor/src/web/uploads/output_20250107_230523.md

@@ -0,0 +1,229 @@
+# Andrew Ng Explores The Rise Of AI Agents And Agentic Reasoning | BUILD 2024 Keynote
+
+Canal: Snowflake Inc.
+Data: 20241119
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=KrRD7r7y7NY
+Idioma: English (auto-generated)
+
+# Bem-vindo, Andrew: O Futuro das Oportunidades da IA
+
+[Aplausos]
+
+Obrigado! É um momento fantástico para ser um construtor, e estou entusiasmado por estar de volta ao Snowflake Build. Hoje, gostaria de partilhar onde penso que estão algumas das maiores oportunidades da IA.
+
+## A IA como a Nova Eletricidade
+
+Já me devem ter ouvido dizer que acho que a IA é a nova eletricidade. Isso porque a IA, tal como a eletricidade, é uma tecnologia de propósito geral. Se vos perguntar: "Para que serve a eletricidade?", é difícil responder porque serve para tantas coisas diferentes. Da mesma forma, a nova tecnologia de IA está a criar um enorme conjunto de oportunidades para construirmos aplicações que antes não eram possíveis.
+
+## A Pilha da IA
+
+As pessoas perguntam-me muitas vezes: "Ei, Andrew, onde estão as maiores oportunidades da IA?" Isto é o que eu considero como a pilha da IA:
+
+- **Semicondutores**: No nível mais baixo.
+- **Infraestrutura Cloud**: Incluindo, claro, a Snowflake.
+- **Modelos de Base**: Os treinadores e modelos construídos em cima da infraestrutura.
+
+Muito do entusiasmo mediático e das conversas nas redes sociais tem-se focado nestas novas camadas tecnológicas. Quando surge uma nova tecnologia como a IA generativa, a excitação naturalmente gravita em torno destas camadas fundamentais. Não há nada de errado com isso, mas acredito que há outra camada da pilha que tem de funcionar ainda melhor: a **camada de aplicações**.
+
+Precisamos de aplicações para gerar ainda mais valor e receita para suportar os fornecedores de tecnologia abaixo. É por isso que passo muito do meu tempo a pensar em aplicações de IA, e acredito que é aí que estão muitas das melhores oportunidades.
+
+## Desenvolvimento Mais Rápido de Modelos de Machine Learning
+
+Uma das tendências que tem vindo a crescer nos últimos anos, em grande parte devido à IA generativa, é o desenvolvimento mais rápido de modelos de machine learning. A IA generativa está a permitir-nos construir coisas mais rapidamente do que nunca.
+
+Por exemplo, tomemos o problema de construir uma ferramenta de análise de sentimentos—pegar em texto e determinar se é positivo ou negativo para monitorização de reputação. Um fluxo de trabalho típico usando aprendizagem supervisionada pode levar um mês para recolher dados rotulados, alguns meses para treinar o modelo, e mais alguns meses para o implementar num serviço cloud. No passado, sistemas de IA valiosos podiam levar boas equipas de IA seis a 12 meses para construir.
+
+Com a IA generativa, no entanto, há certas classes de aplicações onde se pode escrever um prompt em dias e implementá-lo tão rapidamente. Isto significa que aplicações que antes levavam meses a construir podem agora ser construídas em talvez 10 dias. Isto abre oportunidades para experimentar, construir novos protótipos e lançar novos produtos de IA.
+
+### Experimentação Rápida como Caminho para a Invenção
+
+A experimentação rápida está a tornar-se um caminho mais promissor para a invenção. Anteriormente, se levava seis meses a construir algo, tínhamos de estudá-lo, garantir que havia procura do utilizador, e documentá-lo antes de nos comprometermos com o esforço. Agora, para equipas de IA em rápida evolução, o padrão de design é juntar um protótipo num fim de semana, construir 20 protótipos, e ver o que resulta. Se 18 deles não funcionarem, ficamos com o que funciona.
+
+Esta iteração e experimentação rápidas estão a tornar-se um novo caminho para inventar novas experiências de utilizador. Uma implicação interessante é que as **avaliações (ou "evals")** estão a tornar-se um maior estrangulamento na forma como construímos coisas.
+
+No mundo da aprendizagem supervisionada, se estiveres a recolher 10.000 pontos de dados para treinar um modelo, recolher mais 1.000 para testes é apenas um aumento de 10% no custo. Mas para muitas aplicações baseadas em modelos de linguagem grandes, se não houver necessidade de dados de treino, abrandar para recolher 1.000 exemplos de teste pode parecer um enorme estrangulamento.
+
+O novo fluxo de trabalho de desenvolvimento muitas vezes parece que estamos a construir e a recolher dados em paralelo em vez de sequencialmente. Construímos um protótipo, e à medida que se torna mais importante, gradualmente construímos o conjunto de testes em paralelo. Vejo inovações emocionantes ainda por vir na forma como construímos avaliações.
+
+## A Velocidade de Prototipagem vs. Produção
+
+A prototipagem de modelos de machine learning tornou-se muito mais rápida, mas construir uma aplicação de software envolve muitos passos: O produto funciona? O design funciona? A integração do software funciona? Há muita "canalização" envolvida. Após a implementação, há DevOps e LOps.
+
+Algumas destas outras peças estão a tornar-se mais rápidas, mas não aceleraram ao mesmo ritmo que a modelação de machine learning. Assim, enquanto a prototipagem é agora muito rápida, levar um protótipo para uma produção robusta e fiável com guardrails ainda leva tempo. A dinâmica interessante é que a velocidade do machine learning está a pressionar as organizações a acelerar todas estas outras partes também.
+
+## Mover Rápido e Ser Responsável
+
+O mantra "mover rápido e partir coisas" ganhou má reputação porque, bem, partiu coisas. Algumas pessoas interpretam isto como significando que não devemos mover rápido, mas discordo. Acho que o melhor mantra é **"mover rápido e ser responsável."**
+
+Estou a ver muitas equipas capazes de prototipar rapidamente, avaliar e testar robustamente sem enviar nada para o mundo mais amplo que possa causar danos ou prejuízos significativos. Equipas inteligentes estão a construir rapidamente e a mover-se rápido, mas também a fazê-lo de uma forma muito responsável. Isto é emocionante—ser capaz de construir e enviar coisas responsavelmente muito mais rápido do que nunca.
+
+## A Ascensão dos Fluxos de Trabalho de IA Agente
+
+De todas as tendências técnicas em IA, aquela que mais me entusiasma são os **fluxos de trabalho de IA agente**. Se me perguntassem qual é a tecnologia de IA mais importante a prestar atenção, diria que é a IA agente.
+
+Quando comecei a falar sobre isto no início deste ano, foi um pouco controverso, mas agora o termo "agentes de IA" tornou-se amplamente utilizado—tanto por pessoas técnicas como não técnicas. Tornou-se um pouco num termo de moda, mas deixem-me partilhar como vejo os agentes de IA e porque acho que são importantes.
+
+### Prompting Zero-Shot vs. Fluxos de Trabalho Agentes
+
+A maioria de nós usa modelos de linguagem grandes hoje com **prompting zero-shot**. Isto significa que damos ao modelo um prompt e pedimos-lhe para gerar uma saída—como escrever um ensaio—do início ao fim de uma só vez, sem qualquer retrocesso ou revisões. É como pedir a alguém para escrever um ensaio desde a primeira palavra até à última sem parar.
+
+Embora os modelos de linguagem grandes se saiam bastante bem com esta abordagem, não é assim que fazemos a nossa melhor escrita. Um **fluxo de trabalho agente**, por outro lado, é mais iterativo. Por exemplo, para gerar um ensaio, podemos pedir à IA para:
+
+1. Escrever um esboço do ensaio.
+2. Realizar pesquisa na web (se necessário) e descarregar páginas relevantes para incluir no contexto do modelo.
+3. Escrever o primeiro rascunho.
+4. Criticar o primeiro rascunho e fazer revisões.
+
+Este processo iterativo permite saídas mais refinadas e de maior qualidade, e é uma das razões pelas quais estou tão entusiasmado com o potencial dos fluxos de trabalho de IA agente.
+
+---
+
+Em conclusão, a IA está a abrir oportunidades incríveis para os construtores, e estou entusiasmado por ver quão rápido o campo está a evoluir. Desde a prototipagem mais rápida até ao desenvolvimento responsável e à ascensão da IA agente, o futuro da IA é brilhante, e mal posso esperar para ver o que vamos construir a seguir. Obrigado!
+
+# Fluxos de Trabalho Agentes: Revolucionando o Desempenho da IA
+
+## Introdução aos Fluxos de Trabalho Agentes
+
+Ao rever um rascunho ou realizar tarefas complexas, o fluxo de trabalho envolve frequentemente um processo cíclico de pensar, pesquisar, rever e iterar. Este ciclo, embora demorado, melhora significativamente a qualidade do resultado. Em várias equipas com as quais colaboro, aplicamos este **fluxo de trabalho agente** para lidar com tarefas intrincadas, como o processamento de documentos legais complexos, assistência em diagnósticos de saúde e gestão de documentação de conformidade governamental. Esta abordagem produz consistentemente resultados superiores em comparação com métodos tradicionais.
+
+## O Poder dos Fluxos de Trabalho Agentes na IA
+
+Uma área que me entusiasma particularmente discutir é a **IA visual**, onde os fluxos de trabalho agentes permitem o processamento de dados de imagem e vídeo. Mas antes de mergulharmos nisso, vamos explorar alguns benchmarks que destacam a eficácia dos fluxos de trabalho agentes.
+
+### Benchmarking de Fluxos de Trabalho Agentes
+
+O **Benchmark HumanEval**, desenvolvido pela OpenAI, mede a capacidade dos grandes modelos de linguagem para resolver puzzles de codificação. A minha equipa recolheu dados sobre este benchmark, e os resultados são impressionantes:
+
+- **GPT-3.5** alcançou uma taxa de sucesso de 48%.
+- **GPT-4** mostrou uma melhoria significativa, atingindo 67%.
+- No entanto, a melhoria mais notável veio do **GPT-3.5 usando um fluxo de trabalho agente**, que alcançou uma taxa de sucesso de 95%.
+- **GPT-4 com um fluxo de trabalho agente** também teve um desempenho excecional.
+
+Estes resultados demonstram que os fluxos de trabalho agentes podem melhorar dramaticamente o desempenho dos modelos de IA.
+
+---
+
+## Quatro Padrões de Design Principais para Fluxos de Trabalho Agentes
+
+Para compreender melhor os fluxos de trabalho agentes, vamos decompor os quatro padrões de design principais que os desenvolvedores utilizam para os construir:
+
+### 1. Reflexão
+A reflexão envolve solicitar a um modelo de linguagem que critique e melhore o seu próprio output. Por exemplo:
+1. Solicitar ao modelo que gere código para uma tarefa específica.
+2. Copiar o código gerado de volta para o prompt e pedir ao modelo que o critique.
+3. Utilizar o feedback para melhorar o código.
+4. Opcionalmente, executar testes unitários e incorporar os resultados em iterações posteriores.
+
+Este processo iterativo eleva frequentemente o desempenho de base para um nível superior. A reflexão também pode prenunciar **fluxos de trabalho multiagentes**, onde um modelo desempenha o papel de codificador enquanto outro atua como crítico.
+
+### 2. Utilização de Ferramentas
+Neste padrão de design, um modelo de linguagem é solicitado a gerar pedidos para chamadas de API. Por exemplo, pode decidir:
+- Pesquisar na web.
+- Executar código.
+- Emitir um reembolso ao cliente.
+- Enviar um email.
+- Consultar uma entrada de calendário.
+
+Esta capacidade de fazer chamadas de função expande significativamente as capacidades dos fluxos de trabalho agentes.
+
+### 3. Planeamento
+O planeamento envolve decompor tarefas complexas numa sequência de ações. Por exemplo:
+1. Utilizar um modelo OpenPose para detetar uma pose numa imagem.
+2. Gerar uma imagem com base na pose detetada.
+3. Descrever a imagem.
+4. Utilizar text-to-speech (TTS) para gerar áudio.
+
+Ao planear e executar tarefas passo a passo, os modelos podem lidar com pedidos mais complexos de forma eficaz.
+
+### 4. Colaboração Multiagente
+Neste padrão, um único modelo de linguagem é solicitado a desempenhar múltiplos papéis, simulando interações entre diferentes agentes. Por exemplo:
+- Um agente pode especializar-se em codificação.
+- Outro pode focar-se na revisão e crítica do código.
+
+Esta abordagem tem demonstrado melhorar o desempenho numa variedade de tarefas. É análogo a executar múltiplos processos numa CPU—cada processo lida com uma subtarefa específica, permitindo ao sistema abordar problemas maiores e mais complexos.
+
+---
+
+## A Ascensão dos Agentes Multimodais
+
+Embora grande parte do foco tenha sido nos **grandes modelos de linguagem (LLMs)**, estou particularmente entusiasmado com o potencial dos **grandes modelos multimodais (LMMs)**. Estes modelos podem processar não apenas texto, mas também imagens e vídeos.
+
+Por exemplo, dada uma imagem, um LMM pode realizar **prompting zero-shot**—essencialmente, dar uma vista de olhos na imagem e fornecer um output. No entanto, tal como com os LLMs, os fluxos de trabalho agentes podem melhorar o desempenho dos LMMs. Ao decompor tarefas em passos mais pequenos—como detetar rostos, identificar números e sintetizar a informação—estes modelos podem lidar com tarefas mais complexas de forma eficaz.
+
+---
+
+## Demonstração: Fluxos de Trabalho Agentes na IA Visual
+
+Para ilustrar o poder dos fluxos de trabalho agentes, vamos ver uma demonstração desenvolvida por **Dan Malone** e pela **equipa H AI**. Utilizaremos uma imagem de um jogo de futebol e solicitaremos ao modelo que conte os jogadores na imagem.
+
+### Como Solicitar ao Modelo
+Após carregar uma imagem, pode utilizar os prompts sugeridos pelo sistema. Por exemplo:
+- “Conte os jogadores na imagem.”
+- “Identifique as posições dos jogadores.”
+- “Descreva a ação na cena.”
+
+Ao aproveitar os fluxos de trabalho agentes, o modelo pode realizar estas tarefas com uma precisão e eficiência notáveis.
+
+---
+
+## Conclusão
+
+Os fluxos de trabalho agentes representam um salto significativo nas capacidades da IA. Ao incorporar **reflexão**, **utilização de ferramentas**, **planeamento** e **colaboração multiagente**, os desenvolvedores podem construir sistemas que abordam tarefas complexas com uma eficácia sem precedentes. A ascensão dos **agentes multimodais** expande ainda mais as possibilidades, permitindo que a IA processe e analise diversos tipos de dados.
+
+À medida que continuamos a explorar e refinar estes fluxos de trabalho, as aplicações potenciais são virtualmente ilimitadas—desde o processamento de documentos legais até diagnósticos de saúde e muito mais. O futuro da IA não se trata apenas de construir modelos mais inteligentes, mas também de conceber fluxos de trabalho que desbloqueiem o seu potencial total.
+
+# Vision Agent: Transformação do Processamento de Dados de IA Visual
+
+Deixe-me demonstrar como isto funciona. Vamos começar por contar o número de jogadores em campo. Isto inicia um processo que decorre durante alguns minutos para pensar em como escrever código que conte com precisão o número de jogadores no frame. Isto é um pouco complexo porque não queremos contar jogadores em segundo plano.
+
+Já executei isto anteriormente, por isso vamos saltar para o resultado. O código selecionou sete jogadores em campo e, ao contar, verificamos que está correto: 1, 2, 3, 4, 5, 6, 7. Ao ampliar a saída do modelo, confirmamos esta precisão.
+
+## Geração de Código Reutilizável
+
+Um dos resultados é a geração de código Python que pode ser executado repetidamente numa grande coleção de imagens. Isto é particularmente interessante para empresas e equipas com grandes quantidades de dados de IA visual — imagens e vídeos armazenados em vários locais. Até agora, extrair valor destes dados tem sido um desafio.
+
+Para pequenas equipas ou grandes empresas com vastos dados visuais, capacidades como o Vision Agent permitem-lhe aproveitar dados previamente armazenados e extrair valor real deles. Isto representa uma transformação significativa na IA.
+
+## Exemplo de Processamento de Vídeo
+
+Aqui está outro exemplo: dado um vídeo de um jogo de futebol, a tarefa é dividir o vídeo em clips de 5 segundos e encontrar o clip onde um golo é marcado, depois exibir o frame relevante. O sistema gera e avalia o código, e a saída indica que um golo foi marcado por volta do minuto 10:15. Também extrai os frames associados, tornando-o altamente útil para processar dados de vídeo.
+
+## Geração de Metadados
+
+Outra funcionalidade poderosa é a capacidade de dividir um vídeo de entrada em segmentos de 6 segundos, descrever cada segmento e armazenar a informação num Pandas DataFrame juntamente com os nomes dos clips e os tempos de início/fim. Estes metadados podem então ser armazenados em plataformas como o Snowflake, permitindo o desenvolvimento de outras aplicações.
+
+Para demonstrar, construímos uma aplicação de demonstração usando código gerado pelo Vision Agent. Esta aplicação indexa uma coleção de vídeos, permitindo aos utilizadores pesquisar conteúdo específico. Por exemplo, pesquisar por "esquiador no ar" mostra clips com alta similaridade, marcados a verde na linha do tempo. Outra pesquisa por "lobo cinzento à noite" destaca as partes relevantes do vídeo.
+
+## Aplicações Práticas
+
+Esta tecnologia tem inúmeras aplicações práticas. Por exemplo, se estiver à procura da sua mala preta com uma alça arco-íris entre muitos itens semelhantes, o sistema pode rapidamente identificar a correta. As possibilidades são infinitas, e o esforço necessário para construir tais aplicações é agora menor do que nunca.
+
+## Tendências e Oportunidades em IA
+
+Em termos de oportunidades em IA, os workflows agenticos estão a mudar o stack de IA. Há uma nova camada emergente de orquestração agentica, tornando mais fácil para os desenvolvedores construir aplicações. O Vision Agent da Landing AI contribui para isto ao simplificar o processamento de dados de imagem e vídeo.
+
+### Principais Tendências em IA
+
+1. **Velocidade de Geração de Tokens**: Os workflows agenticos geram muitos tokens, e há esforços emocionantes para acelerar este processo através de avanços em semicondutores e software.
+2. **Otimização do Uso de Ferramentas**: Os grandes modelos de linguagem estão cada vez mais ajustados para suportar o uso de ferramentas, melhorando as suas capacidades em workflows agenticos.
+3. **Engenharia de Dados**: A importância da engenharia de dados está a aumentar, especialmente para gerir dados não estruturados como texto, imagens e vídeo.
+4. **Revolução dos Dados Visuais**: Enquanto o processamento de texto já revolucionou muitos campos, a revolução do processamento de imagens está a caminho, prometendo desbloquear ainda mais valor a partir de dados visuais.
+
+Estas tendências estão a moldar o futuro da IA, e estou entusiasmado com as novas possibilidades que trazem.
+
+# A Era da Inteligência Artificial Generativa
+
+Este é um momento extraordinário para ser um desenvolvedor. A Inteligência Artificial Generativa está a permitir-nos aprender e experimentar mais rapidamente do que nunca. Esta tecnologia está a expandir o leque de possibilidades, abrindo portas para inúmeras novas aplicações que podemos construir - tanto no campo da IA visual como noutras áreas - que simplesmente não eram viáveis anteriormente.
+
+## Experimente Você Mesmo
+
+Se estiver interessado em explorar as demonstrações de IA visual que apresentei, visite [va.landing.ai](https://va.landing.ai). Neste site, poderá testar exatamente as mesmas demonstrações que mostrei, obter o código e implementá-lo nas suas próprias aplicações.
+
+## Agradecimentos
+
+Por fim, gostaria de expressar o meu agradecimento a todos. E, por favor, juntem-se a mim para dar as boas-vindas de volta ao palco à Elsa. Obrigado!
+
+---

kb-processor/src/web/uploads/output_20250107_230648.md

@@ -0,0 +1,132 @@
+# NEW Deepseek-V3 Computer Use AI Agents are INSANE (FREE!) 🤯
+
+Canal: Julian Goldie SEO
+Data: 20250107
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=K0qlaCIle1Y
+Idioma: English (auto-generated)
+
+# Como Utilizar o Browser Use Web UI: Um Guia Completo
+
+Hoje, vou mostrar exatamente como utilizar o **Browser Use Web UI**, um poderoso agente de IA que pode ser configurado gratuitamente diretamente no seu navegador. Este agente é capaz de realizar qualquer tarefa que lhe solicitar, e vou mostrar-lhe como configurá-lo de forma simples e rápida.
+
+## O Que Pode Fazer com o Browser Use Web UI?
+
+O Browser Use Web UI permite configurar um agente de IA personalizado. Pode:
+
+- **Escolher o tipo de agente**: Por exemplo, selecionar "Custom" para personalizar as ações.
+- **Definir múltiplas etapas**: O agente pode realizar várias tarefas sequenciais.
+- **Usar visão ou não**: O agente pode "ver" o seu ecrã ou não, dependendo da configuração.
+- **Integrar APIs**: Pode selecionar diferentes APIs, como a **DeepSeek Versão 3**, e inserir a sua chave de API diretamente.
+- **Escolher entre utilizar o seu próprio navegador ou o navegador do Web UI**.
+
+Além disso, pode atribuir tarefas ao agente e acompanhar o processo em tempo real, o que é extremamente útil para compreender como ele funciona.
+
+---
+
+## Como Configurar o Browser Use Web UI
+
+### Passo 1: Instalação
+
+1. Aceda às instruções no **GitHub** do Browser Use Web UI.
+2. Certifique-se de que tem o **Python 3.1 ou superior** instalado.
+3. No terminal, siga as instruções passo a passo para configurar o ambiente.
+
+Se encontrar problemas durante a instalação, pode colar os erros no terminal ou em ferramentas como o **Claw** para obter soluções específicas.
+
+### Passo 2: Configuração do Agente
+
+1. **Selecione o tipo de agente**: Escolha "Custom" para personalizar.
+2. **Defina o número máximo de etapas**: O padrão é 100, mas pode ajustar conforme necessário.
+3. **Escolha a API**: Se estiver a utilizar a **DeepSeek Versão 3**, insira a sua chave de API e selecione o modelo correspondente (por exemplo, "DeepSeek Hi from Chat").
+4. **Decida se utiliza o seu próprio navegador ou o navegador do Web UI**: Para melhores resultados, recomendo utilizar o navegador do Web UI.
+
+---
+
+## Utilizar o Agente para Tarefas Práticas
+
+### Exemplo 1: Pesquisar no Google
+
+Vamos testar o agente com uma tarefa simples:
+
+1. **Tarefa**: "Vá para google.com, digite 'OpenAI', clique em pesquisar e dê-me o primeiro URL."
+2. **Execute o agente**: Ele navegará até ao Google, digitará "OpenAI", fará a pesquisa e retornará o primeiro link.
+
+Durante o processo, o agente analisa a página utilizando visão e executa as ações sem intervenção humana. Pode até gravar a sessão e reproduzi-la posteriormente, o que é ideal para criar tutoriais ou demonstrações.
+
+### Exemplo 2: Pesquisa de Palavras-Chave
+
+Outra tarefa interessante é utilizar o agente para pesquisar palavras-chave:
+
+1. **Tarefa**: "Vá para ahrefs.com, aceda ao Keyword Explorer, pesquise palavras-chave para a minha agência de SEO."
+2. **Execute o agente**: Ele navegará até ao site, fará a pesquisa e retornará os resultados.
+
+No entanto, observe que o agente funciona melhor no navegador do Web UI do que no seu próprio navegador.
+
+---
+
+## Testar os Limites do Agente
+
+Vamos desafiar o agente com uma tarefa mais complexa:
+
+1. **Tarefa**: "Vá para google.com, digite 'melhor agência de SEO no Japão', crie um esboço de conteúdo com base nos concorrentes."
+2. **Execute o agente**: Ele navegará até ao Google, fará a pesquisa, analisará os resultados e criará um esboço em markdown.
+
+O agente é capaz de seguir etapas mais complexas e realizar análises detalhadas, algo que outros agentes de IA, como o **Claude Computer Agent**, não conseguem fazer com tanta eficiência.
+
+---
+
+## Benefícios e Custo
+
+- **Custo**: Utilizar a API da DeepSeek é extremamente barato. Por exemplo, um saldo de $10 pode durar semanas, com custos de apenas alguns cêntimos por utilização.
+- **Flexibilidade**: Pode personalizar o agente para diversas tarefas, desde pesquisas simples até análises complexas.
+- **Gravação de Sessões**: A capacidade de gravar as ações do agente é ideal para criar tutoriais ou documentar processos.
+
+---
+
+## Conclusão
+
+O **Browser Use Web UI** é uma ferramenta poderosa para automatizar tarefas no navegador. Com configuração simples e custos baixos, pode ser utilizado para uma variedade de aplicações, desde pesquisas até análises de SEO. Experimente e veja como ele pode otimizar o seu fluxo de trabalho!
+
+Para mais detalhes, aceda ao [GitHub do Browser Use Web UI](https://github.com/browseruse/webui) e siga as instruções passo a passo.
+
+# Como Escolher a Agência de SEO Certa e o Impacto dos Agentes de IA
+
+## Introdução
+Escolher a agência de SEO certa pode ser um desafio, especialmente com tantas opções disponíveis. Uma agência que se destaca geralmente oferece serviços robustos e resultados comprovados. Mas como pode tomar a decisão certa? Vamos explorar isso e também discutir como os agentes de IA estão a transformar o cenário digital.
+
+## A Evolução dos Agentes de IA
+Recentemente, tenho experimentado várias ferramentas de IA para tarefas do dia-a-dia. Por exemplo, ao pesquisar voos baratos de Bangkok para o Reino Unido, usei uma IA que atua como assistente executivo. A vantagem de usar APIs modernas, como DeepSeek versão 3 ou Gemini Flash Experimental, é que oferecem resultados muito mais precisos e atualizados. Em contraste, ferramentas mais antigas, como o CLA Computer, que não são atualizadas há meses, não conseguem competir.
+
+### Desafios com Navegadores
+Tentei usar o meu próprio navegador para essas tarefas, mas deparei-me com vários erros. Parece que há algumas configurações que precisam de ser ajustadas, mas até agora não consegui fazê-lo funcionar. Portanto, desativei essas funcionalidades e voltei a usar a IA para obter os resultados desejados.
+
+## O Impacto dos Agentes de IA no Mercado de Trabalho
+A capacidade de realizar tarefas administrativas básicas, como clicar em botões, está a ser rapidamente substituída por agentes de IA. Estes agentes estão apenas no início da sua evolução e só vão melhorar com o tempo. Empresas como ChatGPT, Claude e Google estão prestes a lançar os seus próprios agentes, o que deve acontecer nos próximos meses.
+
+### Custos e Eficiência
+Quando tem a opção de usar um agente de IA ou contratar um assistente virtual que custa $5 a $15 por hora, a escolha é clara. Para empresas e profissionais que dependem de assistência executiva, os agentes de IA são uma solução mais económica e eficiente.
+
+## Mudanças no Mercado de Trabalho
+Nos últimos 12 a 24 meses, desde que comecei a usar o ChatGPT, percebi uma mudança significativa. Não contratamos mais redatores humanos, nem fotógrafos. Todo o conteúdo do meu canal principal de IA é editado com ferramentas como Dript, sem intervenção humana. Isto está a acontecer em tempo real e é crucial experimentar estas tecnologias, mesmo que não sejam perfeitas, porque estão a moldar o futuro.
+
+### Exemplo Prático: Desenvolvimento de Software
+Até mesmo no desenvolvimento de software, a necessidade de contratar desenvolvedores front-end diminuiu. Ferramentas como Bolt DIY permitem criar ferramentas SAS em minutos, sem custo algum e com muita rapidez. É essencial entender estas mudanças e adaptar-se.
+
+## Exemplo de Uso: Pesquisa de Voos
+Vamos ver um exemplo prático. Usei um agente de IA para encontrar o voo mais barato de Bangkok para o Reino Unido. O resultado foi detalhado: o voo mais barato encontrado foi para Londres, custando 23.000, com partida a 12 de maio e regresso a 25 de maio, com uma escala e tempo total de viagem de 19 horas e 50 minutos. As companhias aéreas envolvidas foram Shanghai Airlines e China Eastern.
+
+### Comparação com Assistência Humana
+Esta análise é mais rápida, barata e fácil do que contratar um assistente humano para fazer a mesma tarefa. Em seis meses ou um ano, o cenário pode mudar ainda mais, e é importante estar preparado.
+
+## Conclusão
+Agradeço por assistir ao vídeo. Se quiser acesso completo a todos os SCPs e instruções sobre como configurar estas ferramentas, inscreva-se no meu curso gratuito de SEO. O link está na descrição do vídeo. Lá, também encontrará 50 casos de uso e prompts práticos para aplicar estas técnicas em tempo real.
+
+### Bónus: Estratégia de SEO Gratuita
+Além disso, se quiser uma sessão gratuita de estratégia de SEO, mostrando como levamos sites de 0 a 145.000 visitas por mês e geramos centenas de milhares de dólares em vendas no piloto automático, agende uma sessão. Vai aprender as melhores estratégias de link building, como superar a concorrência e como multiplicar o tráfego orgânico.
+
+Obrigado por assistir e vemo-nos no próximo vídeo!
+
+---

kb-processor/src/web/uploads/output_20250107_230817.md

@@ -0,0 +1,116 @@
+# NEW Deepseek-V3 Computer Use AI Agents are INSANE (FREE!) 🤯
+
+Canal: Julian Goldie SEO
+Data: 20250107
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=K0qlaCIle1Y
+Idioma: English (auto-generated)
+
+# Como Utilizar o Browser Use Web UI: Um Poderoso Agente de IA para o Seu Browser
+
+Hoje, vou mostrar-lhe exatamente como utilizar o **Browser Use Web UI**, um poderoso agente de IA que pode configurar gratuitamente diretamente no seu browser. Este agente de IA pode executar tarefas com base nas suas instruções, e vou guiá-lo pelo processo de configuração e por algumas das suas funcionalidades mais impressionantes.
+
+---
+
+## Configuração do Browser Use Web UI
+
+Configurar o **Browser Use Web UI** é simples. Eis como pode começar:
+
+1. **Instalação**: Siga as instruções do GitHub fornecidas para o **Browser Use Web UI**. Vai precisar de ter o **Python 3.1 ou superior** instalado. Copie e cole cada instrução no seu terminal para configurá-lo.
+   
+2. **Hospedagem Local**: Após a instalação, pode hospedá-lo localmente. Se encontrar algum problema durante a configuração, pode resolver problemas colando as mensagens de erro em ferramentas como o **Claw** para obter orientação.
+
+---
+
+## Configuração do Agente de IA
+
+Após a configuração, pode configurar o agente de IA de acordo com as suas necessidades:
+
+- **Tipo de Agente**: Selecione **Custom** como o tipo de agente. Pode especificar o número de passos que o agente deve realizar para completar uma tarefa (o padrão é 100 passos).
+  
+- **Configurações de Visão**: Pode escolher se a IA pode "ver" o seu ecrã ou não. Se desativar a visão, a IA não terá acesso ao seu ecrã.
+
+- **Seleção de API**: Pode integrar diferentes APIs, como o **DeepSeek Version 3**. Para utilizar o DeepSeek, basta inserir a sua chave de API e selecionar o nome do modelo (por exemplo, **DeepSeek Hi from Chat**).
+
+---
+
+## Utilização da API DeepSeek
+
+O DeepSeek é uma opção de API acessível. Eis como utilizá-lo:
+
+1. **Obtenha uma Chave de API**: Visite [DeepSeek.com](https://deepseek.com) para criar uma chave de API. O custo é mínimo—recarreguei $10 há uma semana e até agora só gastei 2 cêntimos.
+
+2. **Integração com o Browser Use Web UI**: Copie a chave de API e cole-a nas definições do **Browser Use Web UI**. Selecione o modelo **DeepSeek Hi from Chat**, e está pronto a começar.
+
+---
+
+## Execução de Tarefas com o Agente de IA
+
+O agente de IA pode realizar uma variedade de tarefas. Aqui estão alguns exemplos:
+
+### Exemplo 1: Tarefa de Pesquisa Básica
+- **Tarefa**: Ir para o Google.com, digitar "OpenAI", clicar em pesquisar e recuperar o primeiro URL.
+- **Processo**: A IA navega até ao Google, digita a consulta e analisa a página utilizando visão. Em seguida, extrai o primeiro URL e fornece o resultado.
+
+### Exemplo 2: Investigação Avançada de SEO
+- **Tarefa**: Ir para o Google.com, digitar "Best SEO Agency Japan" e criar um esboço de conteúdo com base na análise da concorrência.
+- **Processo**: A IA navega até ao Google, digita a consulta e analisa os resultados da pesquisa. Identifica as principais agências de SEO no Japão e gera um esboço de conteúdo em formato Markdown.
+
+---
+
+## Gravação de Sessões
+
+Uma das funcionalidades mais destacadas é a capacidade de gravar sessões. Quando o agente de IA interage com o seu browser, pode gravar todo o processo como um screencast. Isto é particularmente útil para:
+
+- **Tutoriais**: Crie tutoriais orientados por IA onde a IA navega e explica ferramentas em tempo real.
+- **Depuração**: Reveja as gravações para compreender como a IA realizou uma tarefa ou para resolver erros.
+
+---
+
+## Definições do Browser
+
+Pode escolher entre utilizar o seu próprio browser ou o browser fornecido pelo **Browser Use Web UI**. Com base na minha experiência, a IA tem um desempenho melhor quando utiliza o seu próprio browser.
+
+---
+
+## Considerações Finais
+
+O **Browser Use Web UI** é uma mudança de jogo para automatizar tarefas no browser. A sua capacidade de lidar com ações complexas, integrar APIs como o DeepSeek e gravar sessões torna-o uma ferramenta versátil para uso pessoal e profissional. Quer esteja a realizar investigação de SEO ou a automatizar tarefas repetitivas, este agente de IA pode poupar-lhe tempo e esforço.
+
+---
+
+Se quiser acompanhar o processo de configuração, consulte as [instruções do GitHub](https://github.com/browser-use-webui) e os meus melhores prompts nas notas do vídeo. Boa automatização!
+
+# Como Escolher a Agência de SEO Certa e o Impacto da IA no Mercado
+
+## Introdução
+Escolher a agência de SEO certa pode ser um desafio, especialmente quando se trata de identificar os pontos fortes dos serviços oferecidos. No entanto, com a pesquisa adequada e uma análise detalhada, é possível tomar decisões mais informadas. Além disso, a evolução da inteligência artificial (IA) está a transformar rapidamente o mercado, substituindo tarefas que antes exigiam assistentes humanos.
+
+## A Evolução da IA e o Seu Impacto no Mercado
+A IA está a revolucionar a forma como realizamos tarefas quotidianas. Por exemplo, ao utilizar APIs avançadas como a DeepSeek versão 3 ou a Gemini Flash Experimental, é possível obter resultados muito mais precisos e eficientes. Em contraste, ferramentas desatualizadas, como o CLA Computer, não oferecem o mesmo nível de desempenho.
+
+### Exemplo Prático: Procura de Voos
+Imagine pedir a um assistente virtual para encontrar o voo mais barato de Banguecoque para o Reino Unido. Com a IA, essa tarefa pode ser realizada em segundos. Recentemente, ao testar essa funcionalidade, encontrei um voo para Londres por 23.000 baht, com partida a 12 de maio e regresso a 25 de maio, com uma escala e um tempo total de viagem de 19 horas e 50 minutos. A companhia aérea era a Shanghai Airlines, operada pela China Eastern.
+
+### Comparação com Assistência Humana
+A questão é: esta solução é mais rápida, barata e fácil do que contratar um assistente humano? Absolutamente. E considerando que a IA só vai melhorar nos próximos meses, é crucial começar a experimentar estas tecnologias agora, mesmo que ainda não sejam perfeitas.
+
+## O Futuro do Trabalho e a IA
+Nos últimos 12 a 24 meses, desde que começámos a usar o ChatGPT, notámos uma mudança significativa na nossa equipa. Já não contratamos redatores humanos, fotógrafos ou editores. Todo o conteúdo do meu canal principal de IA é editado utilizando ferramentas como o Dript, sem intervenção humana.
+
+### Impacto noutras Áreas
+Até mesmo no desenvolvimento de software, a IA está a mudar o jogo. Agora, é possível criar ferramentas SAS em minutos utilizando plataformas como o Bolt DIY, sem custo algum e com uma velocidade impressionante. Isto levanta a questão: quais empregos ainda serão necessários no futuro?
+
+## Conclusão e Recursos Adicionais
+Se está interessado em explorar mais sobre SEO e IA, confira o meu curso gratuito de SEO. Lá, encontrará instruções detalhadas, tutoriais passo a passo, dicas, modelos, 53 ferramentas de SEO e uma comunidade de mais de 3.000 especialistas prontos para ajudar.
+
+### Ofertas Especiais
+- **Sessão Estratégica de SEO Gratuita**: Aprenda como levámos sites de 0 a 145.000 visitas por mês e gerámos centenas de milhares de dólares em vendas no piloto automático.
+- **Plano de Dominação de SEO**: Descubra a melhor estratégia de link building para o seu site e como superar a concorrência.
+- **Aceleração de Link Building**: Aprenda a aumentar o tráfego orgânico em 10x com base no que está a funcionar para nós.
+
+Agradeço por assistir e espero vê-lo no próximo vídeo. Até lá!
+
+---

kb-processor/src/web/uploads/output_20250107_230824.md

@@ -0,0 +1,192 @@
+# Andrew Ng Explores The Rise Of AI Agents And Agentic Reasoning | BUILD 2024 Keynote
+
+Canal: Snowflake Inc.
+Data: 20241119
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=KrRD7r7y7NY
+Idioma: English (auto-generated)
+
+# Bem-vindo, Andrew!
+
+[Aplausos]
+
+É um ótimo momento para ser um construtor. Estou entusiasmado por estar de volta ao Snowflake Build. Hoje, gostaria de partilhar onde vejo as maiores oportunidades da IA.
+
+Já me deve ter ouvido dizer que acredito que a IA é a nova eletricidade. Isto porque a IA é uma tecnologia de propósito geral, tal como a eletricidade. Se perguntar para que serve a eletricidade, é difícil responder, pois serve para tantas coisas diferentes. A nova tecnologia de IA está a criar um enorme conjunto de oportunidades para construirmos novas aplicações que antes não eram possíveis.
+
+## Onde estão as maiores oportunidades da IA?
+
+Muitas pessoas perguntam-me: "Andrew, onde estão as maiores oportunidades da IA?" Aqui está o que considero como a "pilha da IA":
+
+1. **Semicondutores**: Na base, temos os semicondutores.
+2. **Infraestrutura em nuvem**: Em cima disso, há muita infraestrutura em nuvem, incluindo, claro, o Snowflake.
+3. **Modelos de base e treinamento**: No topo, estão muitos dos treinadores de modelos de base e os próprios modelos.
+
+Muitas vezes, o hype dos media e o burburinho nas redes sociais estão concentrados nestas camadas da pilha, especialmente quando surge uma nova tecnologia, como a IA generativa. Não há nada de errado nisso, mas acredito que, por definição, há outra camada da pilha que precisa funcionar ainda melhor: a camada de aplicações. Precisamos que as aplicações gerem ainda mais valor e receita para que possamos pagar os fornecedores de tecnologia abaixo.
+
+## A importância das aplicações de IA
+
+Passo muito tempo a pensar em aplicações de IA e acredito que é aí que estão as melhores oportunidades para construir coisas novas. Uma das tendências que tem vindo a crescer nos últimos anos, em grande parte devido à IA generativa, é o desenvolvimento rápido e cada vez mais acelerado de modelos de aprendizagem automática.
+
+A IA generativa está a permitir-nos construir coisas mais rapidamente do que nunca. Por exemplo, considere o problema de construir um modelo de análise de sentimentos, que decide se um texto tem uma conotação positiva ou negativa para monitorização de reputação. Um fluxo de trabalho típico usando aprendizagem supervisionada poderia levar um mês para recolher dados rotulados, alguns meses para treinar o modelo e mais alguns meses para implementá-lo num serviço em nuvem. Assim, sistemas de IA valiosos poderiam levar de seis a doze meses para serem construídos por boas equipas de IA.
+
+Com a IA generativa, há certas classes de aplicações onde pode escrever um prompt em dias e implementá-lo em poucos dias. Isto significa que muitas aplicações que antes levavam meses para serem construídas agora podem ser feitas em cerca de dez dias. Isto abre a oportunidade de experimentar, construir novos protótipos e lançar novos produtos de IA.
+
+## Prototipagem rápida e experimentação
+
+A prototipagem rápida está a tornar-se um caminho mais promissor para a invenção. Antes, se levava seis meses para construir algo, era preciso estudar, garantir a procura do utilizador, documentar e depois gastar todo esse esforço para construir, na esperança de que valesse a pena. Agora, para equipas de IA ágeis, vejo um padrão de design onde pode dizer: "Vamos construir 20 protótipos num fim de semana e ver o que funciona." Se 18 deles não funcionarem, descartamos e ficamos com o que funciona.
+
+A iteração rápida e a experimentação estão a tornar-se um novo caminho para inventar novas experiências de utilizador. Uma implicação interessante é que as avaliações, ou "evals", estão a tornar-se um gargalo maior para como construímos coisas. No mundo da aprendizagem supervisionada, se já estava a recolher 10.000 pontos de dados para treinar um modelo, recolher mais 1.000 para testes era um aumento de custo de 10%. Mas para muitas aplicações baseadas em modelos de linguagem grandes, se não há necessidade de dados de treinamento, recolher 1.000 exemplos de teste pode parecer um grande gargalo.
+
+O novo fluxo de trabalho de desenvolvimento muitas vezes parece que estamos a construir e a recolher dados em paralelo, em vez de sequencialmente. Construímos um protótipo e, à medida que ele se torna mais importante e a robustez e fiabilidade se tornam mais críticas, gradualmente construímos os testes em paralelo. Vejo inovações emocionantes ainda por vir em como construímos avaliações.
+
+## Prototipagem rápida vs. produção robusta
+
+A prototipagem de aprendizagem automática tornou-se muito mais rápida, mas construir uma aplicação de software envolve muitas etapas: o produto funciona? O design funciona? A integração do software funciona? Há muita "encanação" envolvida. Depois da implementação, há DevOps e L Ops. Algumas destas outras peças estão a tornar-se mais rápidas, mas não na mesma taxa que a parte de modelagem de aprendizagem automática.
+
+O que estou a ver é que a prototipagem é realmente rápida, mas levar um protótipo para uma produção robusta e fiável, com guardrails e tudo mais, ainda leva algum tempo. O interessante é que o facto de a parte de aprendizagem automática ser tão rápida está a pressionar as organizações a acelerar todas as outras partes também. Isto tem sido um progresso emocionante.
+
+## Mova-se rápido e seja responsável
+
+Acredito que o mantra "mova-se rápido e quebre coisas" ganhou uma má reputação porque, bem, quebrou coisas. Algumas pessoas interpretam isso como "não devemos mover-nos rápido", mas discordo. Acho que o melhor mantra é "mova-se rápido e seja responsável". Vejo muitas equipas capazes de prototipar rapidamente, avaliar e testar de forma robusta, sem lançar nada para o mundo externo que possa causar danos ou prejuízos significativos.
+
+Equipas inteligentes estão a conseguir construir rapidamente e mover-se de forma ágil, mas também de maneira responsável. Acho isso empolgante: pode construir e lançar coisas de forma responsável muito mais rápido do que antes.
+
+## O futuro da IA: Fluxos de trabalho agentivos
+
+De todas as tendências técnicas em IA, a que mais me entusiasma são os fluxos de trabalho agentivos de IA. Se me perguntar qual é a tecnologia de IA mais importante para prestar atenção, diria que são os agentes de IA. Quando comecei a falar sobre isto no início deste ano, era uma declaração um tanto controversa, mas agora o termo "agentes de IA" tornou-se amplamente usado, tanto por pessoas técnicas como não técnicas, e acabou por se tornar um pouco um termo de hype.
+
+Deixe-me partilhar como vejo os agentes de IA e por que acho que eles são importantes. Do ponto de vista técnico, a maioria de nós usa modelos de linguagem grandes hoje com o que é chamado de "prompting de tiro zero". Isto significa que damos um prompt e pedimos ao modelo para escrever um ensaio ou gerar uma saída para nós. É como se estivéssemos a pedir a uma pessoa (ou, neste caso, uma IA) para digitar um ensaio do início ao fim, sem usar o backspace, apenas escrevendo direto do início ao fim.
+
+As pessoas não fazem a sua melhor escrita assim, mas, apesar da dificuldade, os modelos de linguagem grandes saem-se bem. Aqui está como seria um fluxo de trabalho agentivo: para gerar um ensaio, pedimos à IA para primeiro criar um esboço do ensaio, fazer alguma pesquisa na web, se necessário, descarregar algumas páginas e colocá-las no contexto do modelo de linguagem grande. Em seguida, escrevemos o primeiro rascunho, lemos e criticamos.
+
+# Fluxos de Trabalho Agentes: A Revolucionar as Aplicações de IA
+
+## Introdução aos Fluxos de Trabalho Agentes
+
+Ao rever um rascunho ou lidar com tarefas complexas, o fluxo de trabalho envolve frequentemente um processo cíclico de pensar, pesquisar, rever e repetir. Esta abordagem iterativa, embora demorada, melhora significativamente a qualidade do resultado. Em muitas equipas com as quais colaboro, aplicamos este **fluxo de trabalho agente** para lidar com tarefas intrincadas, como processar documentos legais complexos, auxiliar em diagnósticos de saúde ou gerir documentação de conformidade governamental. Este método produz consistentemente resultados superiores em comparação com abordagens tradicionais.
+
+Uma área que me entusiasma particularmente discutir nesta apresentação é a **IA visual**, onde os fluxos de trabalho agentes nos permitem processar dados de imagem e vídeo. Mas mais sobre isso adiante.
+
+## Avaliação de Desempenho dos Fluxos de Trabalho Agentes
+
+Testes recentes demonstram a eficácia dos fluxos de trabalho agentes. Por exemplo, o **HumanEval Benchmark**, que avalia os grandes modelos de linguagem da OpenAI em quebra-cabeças de codificação, mostra melhorias notáveis. Aqui está uma análise:
+
+- **GPT-3.5**: Alcançou 48% de precisão no benchmark de codificação.
+- **GPT-4**: Melhorou para 67%, um salto significativo.
+- **GPT-3.5 com Fluxo de Trabalho Agente**: Superou ambos, atingindo aproximadamente 95% de precisão.
+- **GPT-4 com Fluxo de Trabalho Agente**: Também mostrou uma melhoria substancial.
+
+Estes resultados destacam o potencial transformador dos fluxos de trabalho agentes no aprimoramento do desempenho da IA.
+
+## Quatro Padrões de Design Principais nos Fluxos de Trabalho Agentes
+
+Para desmistificar os fluxos de trabalho agentes, vamos explorar os quatro padrões de design principais que os sustentam:
+
+### 1. Reflexão
+A reflexão envolve solicitar a um modelo de linguagem (LM) que critique e melhore o seu próprio output. Eis como funciona:
+
+1. **Prompt Inicial**: Peça ao LM para gerar código para uma tarefa específica.
+2. **Crítica**: Copie o código gerado de volta para o prompt e peça ao LM para o criticar.
+3. **Melhoria**: Use o feedback para solicitar ao LM que refine o código.
+4. **Testes**: Opcionalmente, execute testes unitários e alimente os resultados de volta ao LM para mais refinamento.
+
+Este fluxo de trabalho de reflexão frequentemente eleva o desempenho base para um nível superior.
+
+### 2. Uso de Ferramentas
+Neste padrão, o LM é solicitado a gerar pedidos para chamadas de API, permitindo-lhe realizar tarefas como pesquisas na web, execução de código ou envio de emails. Isto expande significativamente as capacidades dos fluxos de trabalho agentes.
+
+### 3. Planeamento
+O planeamento envolve dividir tarefas complexas numa sequência de ações. Por exemplo, se solicitado a gerar uma imagem de uma rapariga a ler um livro, o LM poderá:
+
+1. Usar um **modelo OpenPose** para detetar a pose.
+2. Gerar a imagem.
+3. Descrever a imagem.
+4. Usar **Text-to-Speech (TTS)** para gerar áudio.
+
+Esta abordagem passo a passo garante a execução bem-sucedida de tarefas complexas.
+
+### 4. Colaboração Multi-Agente
+Aqui, o LM é solicitado a desempenhar diferentes papéis em várias fases de uma tarefa. Por exemplo, um agente pode gerar código enquanto outro o critica. Esta abordagem colaborativa frequentemente leva a uma melhoria de desempenho, semelhante à forma como múltiplos processos numa CPU lidam com diferentes subtarefas.
+
+## A Ascensão dos Agentes Baseados em Modelos Multimodais
+
+Para além dos modelos de linguagem, **grandes modelos multimodais (LMMs)** estão a revolucionar os fluxos de trabalho agentes. Por exemplo, ao processar uma imagem, um LMM pode:
+
+1. Detetar rostos.
+2. Identificar números.
+3. Combinar a informação para entregar um output abrangente.
+
+Esta abordagem passo a passo e agente permite resultados mais complexos e precisos.
+
+## Demonstração: IA Visual em Ação
+
+Para ilustrar, vejamos uma demonstração envolvendo uma imagem de um jogo de futebol. A tarefa é contar os jogadores no vídeo. Após carregar a imagem, o sistema sugere prompts, como "Contar os jogadores no vídeo", permitindo ao agente realizar a tarefa de forma eficiente.
+
+## Conclusão
+
+Os fluxos de trabalho agentes, com os seus quatro padrões de design principais—reflexão, uso de ferramentas, planeamento e colaboração multi-agente—oferecem um quadro robusto para construir sistemas de IA avançados. Estes fluxos de trabalho não só melhoram o desempenho como também abrem novas possibilidades que eram inimagináveis há apenas um ano. A integração de modelos multimodais expande ainda mais estas capacidades, pavimentando o caminho para aplicações ainda mais sofisticadas.
+
+# Vision Agent: Revolucionando as Aplicações de IA Visual
+
+Deixe-me demonstrar como isto funciona. Vamos começar por contar o número de jogadores em campo. Este processo inicia uma sequência que decorre durante alguns minutos, pensando em como escrever código para contar com precisão o número de jogadores visíveis. Isto é mais complexo do que parece porque queremos excluir os jogadores em segundo plano.
+
+Já executei isto anteriormente, por isso podemos saltar para os resultados. O código identificou sete jogadores em campo. Vamos verificar: 1, 2, 3, 4, 5, 6, 7. Ao ampliar a saída do modelo, confirma-se que esta contagem está correta.
+
+## Geração de Código Reutilizável
+
+Um dos resultados é o código Python gerado que pode ser executado repetidamente em grandes coleções de imagens. Isto é particularmente emocionante porque muitas empresas e equipas têm grandes quantidades de dados de IA visual—imagens e vídeos—armazenados sem uma forma fácil de extrair valor. Para pequenas equipas ou grandes empresas com extensos dados visuais, capacidades como o Vision Agent permitem-lhe aproveitar dados previamente armazenados e extrair valor real deles. Isto representa uma transformação significativa na IA.
+
+## Outro Exemplo: Análise de Vídeo
+
+Aqui está outro exemplo: dado um vídeo de um jogo de futebol, divida o vídeo em clips de 5 segundos e encontre o clip onde é marcado um golo, depois exiba o frame relevante. O sistema gera e avalia o código, produzindo uma saída que identifica o golo por volta da marca de 10:15. Também extrai os frames associados, o que é incrivelmente útil para processar dados de vídeo.
+
+## Geração de Metadados
+
+Vejamos um último exemplo. Pode pedir ao Vision Agent para dividir um vídeo de entrada em segmentos de 6 segundos, descrever cada segmento e armazenar a informação num Pandas DataFrame juntamente com os nomes dos clips e os tempos de início/fim. Estes metadados podem então ser armazenados em plataformas como o Snowflake para construir outras aplicações sobre eles.
+
+Aqui está uma amostra de saída:
+
+- **Nome do Clip**
+- **Tempo de Início**
+- **Tempo de Fim**
+
+O sistema também escreve código que pode ser executado noutro local para gerar descrições de texto para cada clip.
+
+## Aplicação de Demonstração: Indexação de Vídeos
+
+Utilizando as capacidades do Vision Agent, a minha equipa na Landing AI construiu uma aplicação de demonstração que indexa uma coleção de vídeos. Por exemplo, pesquisar por "esquiador no ar" mostra clips com alta similaridade, marcados a verde na linha do tempo. Isto permite uma navegação fácil através de dados de vídeo indexados.
+
+Outra pesquisa por "lobo cinzento à noite" destaca as partes relevantes da linha do tempo do vídeo. Saltar para diferentes partes do vídeo revela outro conteúdo, demonstrando a capacidade do sistema para indexar e pesquisar dados de vídeo de forma eficaz.
+
+## Aplicações Práticas
+
+Considere um cenário onde precisa de encontrar uma mala específica. Procurar por "mala preta com alça arco-íris" entre muitos itens de bagagem pretos pode ser desafiante. O Vision Agent pode ajudar a identificar o item correto rapidamente.
+
+## Oportunidades e Tendências de IA
+
+Em termos de oportunidades de IA, os fluxos de trabalho agentes estão a mudar a stack de IA. Há uma camada emergente de orquestração agentes, tornando mais fácil para os desenvolvedores construir aplicações. O Vision Agent da Landing AI contribui para isto ao simplificar a criação de aplicações de IA visual.
+
+### Tendências Chave de IA
+
+1. **Velocidade de Geração de Tokens**: Fluxos de trabalho agentes geram muito texto ou imagens, exigindo uma geração de tokens mais rápida. Esforços emocionantes no desenvolvimento de semicondutores e software estão a abordar isto.
+   
+2. **Uso de Ferramentas em LLMs**: Modelos de linguagem grandes estão cada vez mais ajustados para suportar o uso de ferramentas, melhorando as suas capacidades em fluxos de trabalho agentes.
+
+3. **Engenharia de Dados**: A importância da engenharia de dados está a aumentar, especialmente com dados não estruturados como texto, imagens e vídeo.
+
+4. **Revolução dos Dados Visuais**: Enquanto o processamento de texto está bem estabelecido, a revolução do processamento de imagens está no horizonte, prometendo desbloquear valor significativo a partir de dados visuais.
+
+Estas tendências estão a moldar o futuro da IA, permitindo aplicações mais sofisticadas e valiosas do que nunca.
+
+# Um Excelente Momento para Ser um Construtor
+
+Este é um excelente momento para ser um construtor. A IA generativa está a permitir-nos experimentar mais rapidamente do que nunca e está a expandir o conjunto de coisas que são agora possíveis. Existem tantas novas aplicações que podemos construir — seja em IA visual ou além — que simplesmente não eram realizáveis antes.
+
+Se estiver interessado em explorar as demonstrações de IA visual que mostrei, visite [va.landing.ai](https://va.landing.ai). Poderá experimentar as mesmas demonstrações que executei, aceder ao código e até executá-lo nas suas próprias aplicações.
+
+Com isto, gostaria de agradecer a todos muito sinceramente. Por favor, juntem-se a mim para dar as boas-vindas de volta ao palco à Elsa. Obrigado!
+
+---

kb-processor/src/web/uploads/output_20250107_231122.md

@@ -0,0 +1,184 @@
+# Andrew Ng Explores The Rise Of AI Agents And Agentic Reasoning | BUILD 2024 Keynote
+
+Canal: Snowflake Inc.
+Data: 20241119
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=KrRD7r7y7NY
+Idioma: English (auto-generated)
+
+# Bem-vindo, Andrew!
+
+[**Aplausos**]
+
+É um ótimo momento para ser um construtor. Estou animado por estar de volta ao **Snowflake Build**. Hoje, gostaria de partilhar onde vejo as maiores oportunidades da **IA**.
+
+Já me deve ter ouvido dizer que acredito que a **IA é a nova eletricidade**. Isto porque a IA é uma tecnologia de propósito geral, tal como a eletricidade. Se eu perguntar: "Para que serve a eletricidade?", é difícil responder, pois serve para tantas coisas diferentes. A nova tecnologia de IA está a criar um enorme conjunto de oportunidades para construirmos aplicações que antes não eram possíveis.
+
+Muitas pessoas perguntam-me: "Andrew, onde estão as maiores oportunidades da IA?" Aqui está o que eu chamo de **pilha da IA**:
+
+1. **Semicondutores** (a camada mais baixa)
+2. **Infraestrutura em nuvem** (incluindo, claro, o Snowflake)
+3. **Modelos e treinadores de modelos de base**
+
+Muito do hype e da empolgação nas redes sociais tem-se concentrado nestas camadas tecnológicas. Quando surge uma nova tecnologia, como a **IA generativa**, o foco está nestas camadas. E não há nada de errado nisso. No entanto, por definição, há outra camada que precisa funcionar ainda melhor: a **camada de aplicações**. Precisamos que as aplicações gerem ainda mais valor e receita para sustentar os fornecedores de tecnologia abaixo.
+
+## Oportunidades na Camada de Aplicações
+
+Passo muito tempo a pensar em aplicações de IA e acredito que é aí que estão as melhores oportunidades para construir coisas novas. Um dos **trends** que tem vindo a crescer nos últimos anos, em grande parte devido à IA generativa, é o desenvolvimento rápido e ainda mais rápido de modelos de aprendizagem automática.
+
+A IA generativa permite-nos construir coisas mais rápido do que nunca. Por exemplo, considere o problema de **análise de sentimento** — pegar num texto e decidir se tem uma conotação positiva ou negativa para monitorização de reputação. Um fluxo de trabalho típico usando aprendizagem supervisionada pode levar um mês a recolher dados rotulados, alguns meses a treinar o modelo e mais alguns meses a implantá-lo num serviço em nuvem. Assim, sistemas de IA valiosos costumavam levar de 6 a 12 meses a serem construídos.
+
+Com a IA generativa, há certas classes de aplicações onde se pode escrever um **prompt** em dias e implantá-lo em poucos dias. Isto significa que muitas aplicações que antes levavam meses a serem construídas agora podem ser feitas em cerca de 10 dias. Isto abre a oportunidade de experimentar, construir novos protótipos e lançar novos produtos de IA.
+
+### Prototipagem Rápida e Experimentação
+
+A prototipagem rápida está a tornar-se um caminho mais promissor para a inovação. Antes, se levava seis meses a construir algo, era preciso estudar, garantir a procura do utilizador, documentar e então construir. Agora, equipas de IA ágeis podem construir 20 protótipos num fim de semana e ver o que funciona. Se 18 deles não funcionarem, descartamos e ficamos com o que funciona. A **iteração rápida** e a **experimentação ágil** estão a tornar-se o novo padrão para inventar novas experiências de utilizador.
+
+### O Gargalo das Avaliações
+
+Uma implicação interessante é que as **avaliações** (ou "evals") estão a tornar-se um gargalo maior no desenvolvimento. No mundo da aprendizagem supervisionada, se já estava a recolher 10.000 pontos de dados, recolher mais 1.000 para testes não era um problema. Mas, em aplicações baseadas em **modelos de linguagem grandes (LLMs)**, se não há necessidade de dados de treino, recolher 1.000 exemplos de teste pode ser um grande gargalo. Assim, o novo fluxo de trabalho de desenvolvimento muitas vezes envolve construir e recolher dados em paralelo, em vez de sequencialmente.
+
+### Prototipagem vs. Produção
+
+A prototipagem de aprendizagem automática tornou-se muito mais rápida, mas construir uma aplicação de software envolve muitas etapas: o produto funciona? O design funciona? A integração do software funciona? Após a implantação, há **DevOps** e **MLOps**. Algumas destas etapas estão a acelerar, mas não na mesma taxa que a modelação de aprendizagem automática. Portanto, embora a prototipagem seja muito rápida, levar um protótipo para produção robusta e fiável ainda leva tempo. No entanto, a velocidade da modelação de aprendizagem automática está a pressionar as organizações a acelerar todas as outras partes do processo.
+
+## Movendo-se Rápido e de Forma Responsável
+
+O mantra **"mova-se rápido e quebre coisas"** ganhou má reputação porque, bem, quebrou coisas. Algumas pessoas interpretam isso como "não devemos mover-nos rápido", mas discordo. Acredito que o melhor mantra é **"mova-se rápido e seja responsável"**. Vejo muitas equipas capazes de prototipar rapidamente, avaliar e testar de forma robusta, sem enviar nada para o mundo externo que possa causar danos. Equipas inteligentes estão a construir e a mover-se rapidamente, mas de forma responsável. Isto é empolgante — pode-se construir e lançar coisas de forma responsável muito mais rápido do que antes.
+
+## O Futuro: Fluxos de Trabalho Agênticos de IA
+
+De todas as tendências técnicas em IA, a que mais me entusiasma são os **fluxos de trabalho agênticos de IA**. Se me perguntar qual é a tecnologia de IA mais importante para prestar atenção, diria que são os **agentes de IA**. No início deste ano, quando comecei a falar sobre isto, era uma afirmação um pouco controversa. Agora, o termo "agentes de IA" tornou-se amplamente utilizado, tanto por pessoas técnicas como não técnicas, e até um pouco hype.
+
+### O que são Agentes de IA?
+
+Do ponto de vista técnico, a maioria de nós usa **modelos de linguagem grandes** com o que chamamos de **prompting zero-shot**. Isto significa que damos um prompt e pedimos que o modelo escreva um ensaio ou gere uma saída de uma vez só, sem revisões. É como pedir a uma pessoa para escrever um ensaio do início ao fim, sem usar o backspace. Embora seja difícil escrever assim, os modelos de linguagem fazem um trabalho decente.
+
+Num **fluxo de trabalho agêntico**, geramos um ensaio de forma mais estruturada. Primeiro, pedimos ao modelo para criar um esboço. Em seguida, perguntamos se é necessário fazer pesquisas na web. Se sim, descarregamos páginas e colocamo-las no contexto do modelo. Depois, escrevemos um primeiro rascunho, lemos, criticamos e refinamos. Este processo iterativo é o que torna os agentes de IA tão poderosos.
+
+---
+
+Esta é a visão que tenho sobre as oportunidades e tendências atuais em IA. Estamos num momento emocionante, onde a velocidade e a responsabilidade podem coexistir, abrindo caminho para inovações incríveis.
+
+# Fluxos de Trabalho Agentes: Revolucionando o Desempenho da IA
+
+## Introdução aos Fluxos de Trabalho Agentes
+
+Ao rever um rascunho ou lidar com tarefas complexas, o fluxo de trabalho envolve frequentemente um processo cíclico de pensar, pesquisar, rever e repetir. Esta abordagem iterativa, embora demorada, resulta em resultados significativamente melhores. Em várias equipas com as quais colaboro, aplicamos este **fluxo de trabalho agente** para lidar com tarefas intrincadas, como o processamento de documentos legais complexos, assistência em diagnósticos de saúde e gestão de documentação de conformidade governamental. Este método produz consistentemente resultados superiores em comparação com abordagens tradicionais.
+
+Uma área que me entusiasma particularmente discutir é a **IA visual**, onde os fluxos de trabalho agentes nos permitem processar dados de imagem e vídeo de forma mais eficaz. Mas mais sobre isso adiante.
+
+## Avaliação Comparativa dos Fluxos de Trabalho Agentes
+
+Avaliações recentes destacam a eficácia dos fluxos de trabalho agentes. Por exemplo, o **HumanEval Benchmark**, que mede a capacidade dos grandes modelos de linguagem (LLMs) para resolver puzzles de codificação, mostra melhorias notáveis quando os fluxos de trabalho agentes são aplicados.
+
+- **GPT-3.5**: Alcançou 48% de precisão no HumanEval Benchmark.
+- **GPT-4**: Melhorou para 67% de precisão.
+- **GPT-3.5 com Fluxo de Trabalho Agente**: Aumentou para aproximadamente 95% de precisão.
+- **GPT-4 com Fluxo de Trabalho Agente**: Também mostrou uma melhoria significativa.
+
+Estes resultados sublinham o potencial transformador dos fluxos de trabalho agentes no aprimoramento do desempenho da IA.
+
+## Quatro Padrões de Design Principais nos Fluxos de Trabalho Agentes
+
+Para compreender melhor os fluxos de trabalho agentes, vamos explorar os quatro padrões de design principais:
+
+### 1. Reflexão
+
+A reflexão envolve solicitar a um LLM que critique e melhore o seu próprio output. Eis como funciona:
+
+1. **Prompt Inicial**: Peça ao LLM para gerar código para uma tarefa específica.
+2. **Crítica**: Copie o código gerado de volta para o prompt e peça ao LLM para o criticar.
+3. **Melhoria**: Use o feedback para solicitar ao LLM que refine o código.
+4. **Teste**: Opcionalmente, execute testes unitários e alimente os resultados de volta ao LLM para um refinamento adicional.
+
+Este fluxo de trabalho de reflexão frequentemente eleva o desempenho base para um nível superior.
+
+### 2. Uso de Ferramentas
+
+Neste padrão de design, um LLM é solicitado a gerar pedidos para chamadas de API, permitindo-lhe realizar tarefas como pesquisas na web, execução de código, reembolsos de clientes, envio de emails ou gestão de calendários. Isto expande as capacidades dos LLMs, permitindo-lhes interagir com sistemas externos e realizar tarefas mais complexas.
+
+### 3. Planeamento
+
+O planeamento envolve a divisão de tarefas complexas numa sequência de ações. Por exemplo, se for solicitado a gerar uma imagem de uma rapariga a ler um livro, um LLM poderá:
+
+1. Usar um **modelo OpenPose** para detetar a pose.
+2. Gerar a imagem.
+3. Descrever a imagem.
+4. Usar **text-to-speech (TTS)** para gerar áudio.
+
+Esta abordagem passo a passo garante que tarefas complexas sejam executadas de forma eficiente.
+
+### 4. Colaboração Multi-Agente
+
+A colaboração multi-agente envolve solicitar a um LLM que desempenhe diferentes papéis em diferentes momentos, simulando múltiplos agentes a trabalhar em conjunto. Este padrão de design tem mostrado melhorias significativas de desempenho em várias tarefas. É semelhante a executar múltiplos processos numa CPU—cada processo especializa-se numa tarefa específica, e a sua interação leva a melhores resultados globais.
+
+## A Ascensão dos Agentes Multimodais
+
+Além dos LLMs baseados em texto, **agentes multimodais** que processam tanto texto como imagens estão a ganhar tração. Por exemplo, um **grande modelo multimodal (LMM)** pode realizar previsões zero-shot em imagens, como contar o número de corredores numa foto. No entanto, tarefas mais complexas beneficiam de um fluxo de trabalho agente, onde o agente planeia, testa e itera para fornecer resultados precisos.
+
+## Demonstração: IA Visual com Fluxos de Trabalho Agentes
+
+Para ilustrar o poder dos fluxos de trabalho agentes na IA visual, consideremos uma demonstração envolvendo uma imagem de um jogo de futebol. A tarefa é contar o número de jogadores na imagem. Ao aplicar um fluxo de trabalho agente, a IA pode:
+
+1. Detetar rostos.
+2. Identificar números de jogadores.
+3. Compilar os dados para fornecer uma contagem precisa.
+
+Esta abordagem passo a passo garante resultados precisos e fiáveis, mostrando o potencial dos fluxos de trabalho agentes em tarefas de IA visual.
+
+## Conclusão
+
+Os fluxos de trabalho agentes, com os seus quatro padrões de design principais—reflexão, uso de ferramentas, planeamento e colaboração multi-agente—oferecem uma estrutura robusta para melhorar o desempenho da IA. Estes fluxos de trabalho permitem-nos abordar tarefas complexas com maior precisão e eficiência, empurrando os limites do que a IA pode alcançar. À medida que continuamos a explorar e refinar estes fluxos de trabalho, as possibilidades para inovação são verdadeiramente emocionantes.
+
+# Vision Agent: Revolucionando o Processamento de Dados Visuais em IA
+
+Vamos explorar como o Vision Agent funciona e as suas potenciais aplicações.
+
+## Contagem de Jogadores em Campo
+
+O processo começa por contar o número de jogadores em campo. Esta tarefa inicia uma operação complexa que decorre durante vários minutos para determinar como escrever código que conte os jogadores com precisão. O desafio reside em garantir que apenas os jogadores em primeiro plano são contados, excluindo os que estão em segundo plano.
+
+Já executei isto anteriormente, por isso podemos saltar diretamente para os resultados. O código identificou sete jogadores em campo: 1, 2, 3, 4, 5, 6, 7. Ao ampliar a saída do modelo, confirma-se que esta contagem está correta.
+
+Uma das saídas é a geração de código Python que pode ser executado repetidamente numa grande coleção de imagens. Esta capacidade é particularmente interessante para empresas e equipas com vastos dados de IA visual, incluindo imagens e vídeos. Até agora, extrair valor destes dados tem sido um desafio. O Vision Agent permite que estas equipas aproveitem eficazmente os seus dados visuais armazenados, marcando uma transformação significativa na IA.
+
+## Processamento de Dados de Vídeo
+
+Eis outro exemplo: dado um vídeo de um jogo de futebol, a tarefa consiste em dividir o vídeo em clips de 5 segundos e identificar o clip onde é marcado um golo. O Vision Agent gera código, avalia-o e produz o resultado. Neste caso, identifica o golo por volta da marca dos 10-15 segundos e extrai os frames relevantes.
+
+Esta funcionalidade é incrivelmente útil para processar dados de vídeo. Por exemplo, pode pedir ao Vision Agent para dividir um vídeo em segmentos de 6 segundos, descrever cada segmento e armazenar a informação num Pandas DataFrame juntamente com o nome do clip, o tempo de início e o tempo de fim. Estes metadados podem então ser armazenados em plataformas como o Snowflake para construir outras aplicações.
+
+## Construção de Aplicações com o Vision Agent
+
+Utilizando as capacidades de geração de código do Vision Agent, a minha equipa na Landing AI desenvolveu uma aplicação de demonstração que indexa uma coleção de vídeos. Por exemplo, pesquisar por "esquiador no ar" recupera clips com alta similaridade, marcados a verde na linha do tempo. Esta demonstração ilustra como o Vision Agent pode ser usado para construir metadados e indexar vídeos de forma eficiente.
+
+Outro exemplo divertido é a procura de bagagem específica. Se estiver à procura de uma mala preta com uma correia arco-íris, o Vision Agent pode ajudar a identificá-la entre muitos itens semelhantes.
+
+## Tendências e Oportunidades em IA
+
+Em termos de oportunidades em IA, os fluxos de trabalho agentes estão a transformar a stack de IA. Está a surgir uma nova camada de orquestração agentes, tornando mais fácil para os desenvolvedores construir aplicações. O Vision Agent contribui para isto ao simplificar o processamento de dados de imagem e vídeo.
+
+Aqui estão quatro tendências-chave em IA que vale a pena notar:
+
+1. **Velocidade de Geração de Tokens**: Os fluxos de trabalho agentes exigem a leitura e geração de muito texto ou imagens, levando a esforços emocionantes para acelerar a geração de tokens através de avanços em semicondutores e software.
+
+2. **Uso de Ferramentas em LLMs**: Os grandes modelos de linguagem estão cada vez mais a ser ajustados para suportar o uso de ferramentas, melhorando as suas capacidades em fluxos de trabalho agentes.
+
+3. **Engenharia de Dados**: A importância da engenharia de dados está a aumentar, especialmente com dados não estruturados. Gerir e implementar estes dados de forma eficaz é crucial para criar valor.
+
+4. **Revolução dos Dados Visuais**: Enquanto o processamento de texto já revolucionou a IA, o processamento de imagem está a seguir o mesmo caminho. As empresas poderão em breve extrair mais valor dos dados visuais do que nunca.
+
+O Vision Agent é uma ferramenta poderosa que reduz a barreira para a construção de aplicações de IA visual, permitindo que as empresas desbloqueiem o potencial dos seus dados visuais armazenados.
+
+# A Era da Construção com IA Generativa
+
+Este é um momento extraordinário para ser um desenvolvedor. A IA generativa está a permitir-nos aprender e experimentar a um ritmo mais acelerado do que nunca. Esta tecnologia está a expandir o leque de possibilidades, abrindo caminho para a criação de novas aplicações que antes eram impensáveis, tanto no campo da IA visual como noutras áreas.
+
+Se se interessou pelos demos de IA visual que apresentei, visite [va.landing.ai](https://va.landing.ai). Lá, poderá testar exatamente as mesmas demonstrações que mostrei, obter o código-fonte e executá-lo nas suas próprias aplicações.
+
+Agradeço a todos pela atenção e peço que se juntem a mim para receber de volta ao palco a Elsa. Muito obrigado!
+
+---

kb-processor/src/web/uploads/output_20250107_231605.md

@@ -0,0 +1,190 @@
+# Andrew Ng Explores The Rise Of AI Agents And Agentic Reasoning | BUILD 2024 Keynote
+
+Canal: Snowflake Inc.
+Data: 20241119
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=KrRD7r7y7NY
+Idioma: English (auto-generated)
+
+# Apresentação de Andrew no Snowflake Build
+
+Por favor, deem as boas-vindas ao Andrew! [Aplausos]
+
+Obrigado! É um momento excelente para ser um construtor. Estou entusiasmado por estar de volta ao Snowflake Build. Hoje, gostaria de partilhar onde penso que se encontram algumas das maiores oportunidades da IA.
+
+Já me devem ter ouvido dizer que considero a IA a nova eletricidade. Isto porque a IA é uma tecnologia de propósito geral, tal como a eletricidade. Se vos perguntar: "Para que serve a eletricidade?", é sempre difícil responder porque serve para tantas coisas diferentes. Da mesma forma, a nova tecnologia de IA está a criar um vasto conjunto de oportunidades para construirmos novas aplicações que antes não eram possíveis.
+
+## A Pilha da IA
+
+As pessoas perguntam-me frequentemente: "Ei Andrew, onde estão as maiores oportunidades da IA?" Isto é o que eu considero como a pilha da IA:
+
+- No nível mais baixo estão os semicondutores.
+- Por cima disso está grande parte da infraestrutura em cloud, incluindo, claro, o Snowflake.
+- Depois, por cima disso, estão muitos dos formadores de modelos de base e os próprios modelos.
+
+Acontece que grande parte do entusiasmo mediático, da excitação e do burburinho nas redes sociais tem-se centrado nestas camadas da pilha — as novas camadas tecnológicas. Quando surge uma nova tecnologia como a IA generativa, o burburinho foca-se nestas camadas tecnológicas. Não há nada de errado com isso, mas penso que, quase por definição, há outra camada da pilha que tem de funcionar ainda melhor, e essa é a camada das aplicações. Precisamos que as aplicações gerem ainda mais valor e ainda mais receitas para que possamos realmente pagar aos fornecedores de tecnologia abaixo.
+
+Passo muito do meu tempo a pensar em aplicações de IA, e acho que é aí que estarão muitas das melhores oportunidades para construir coisas novas.
+
+## Desenvolvimento Rápido e Mais Rápido de Modelos de Machine Learning
+
+Uma das tendências que tem vindo a crescer nos últimos anos, em grande parte devido à IA generativa, é o desenvolvimento rápido e ainda mais rápido de modelos de machine learning. Em particular, a IA generativa está a permitir-nos construir coisas mais rapidamente do que nunca.
+
+Tomemos o problema de construir um classificador de sentimentos — pegar em texto e decidir se é um sentimento positivo ou negativo para monitorização de reputação. Um fluxo de trabalho típico usando aprendizagem supervisionada pode demorar um mês para obter alguns dados rotulados, depois treinar um modelo de IA, o que pode demorar alguns meses, e depois encontrar um serviço em cloud ou algo semelhante para implementar, o que pode demorar mais alguns meses. Assim, durante muito tempo, sistemas de IA muito valiosos podiam demorar seis a 12 meses a serem construídos por boas equipas de IA.
+
+Não há nada de errado com isso; muitas pessoas criam sistemas de IA muito valiosos desta forma. Mas com a IA generativa, há certas classes de aplicações onde se pode escrever um prompt em dias e depois implementá-lo em, novamente, talvez dias. O que isto significa é que há muitas aplicações que antes me levavam a mim e a boas equipas de IA meses a construir e que hoje se podem construir em talvez 10 dias.
+
+Isto abre a oportunidade de experimentar a construção de novos protótipos e lançar novos produtos de IA. Certamente, este é o aspeto de prototipagem. Estas são algumas das consequências desta tendência: a experimentação rápida está a tornar-se um caminho mais promissor para a invenção.
+
+Anteriormente, se demorasse seis meses a construir algo, então era melhor estudá-lo, garantir que havia procura do utilizador, fazer com que os gestores de produto o analisassem, documentá-lo e depois gastar todo esse esforço para o construir, esperando que valesse a pena. Mas agora, para equipas de IA em rápida evolução, vejo um padrão de design onde se pode dizer: "Sabem que mais? Demora-nos um fim de semana a montar um protótipo. Vamos construir 20 protótipos e ver o que resulta. Se 18 deles não funcionarem, simplesmente descartamo-los e ficamos com o que funciona."
+
+Assim, a iteração rápida e a experimentação rápida estão a tornar-se um novo caminho para inventar novas experiências de utilizador.
+
+## Avaliações como um Gargalo
+
+Uma das implicações interessantes é que as avaliações, ou "evals" para abreviar, estão a tornar-se um gargalo maior na forma como construímos coisas. Acontece que, no mundo da aprendizagem supervisionada, se estivermos a recolher 10.000 pontos de dados de qualquer forma para treinar um modelo, então se precisarmos de recolher mais 1.000 pontos de dados para testes, não há problema — um aumento de 10% no custo.
+
+Mas para muitas aplicações baseadas em modelos de linguagem grandes, se não houver necessidade de ter dados de treino, se me obrigarem a abrandar para recolher mil exemplos de teste, isso parece um enorme gargalo. Assim, o novo fluxo de trabalho de desenvolvimento muitas vezes parece que estamos a construir e a recolher dados mais em paralelo do que sequencialmente, em que construímos um protótipo e depois, à medida que se torna mais importante e a robustez e fiabilidade se tornam mais importantes, gradualmente construímos esse conjunto de testes em paralelo.
+
+Mas vejo inovações emocionantes ainda por fazer na forma como construímos evals.
+
+## Prototipagem e Produção
+
+O que também estou a ver é que a prototipagem de machine learning se tornou muito mais rápida, mas a construção de uma aplicação de software tem muitos passos. O produto funciona? O design funciona? A integração de software funciona? Muito trabalho de canalização. Depois, após a implementação, DevOps e LOps. Algumas dessas outras peças estão a tornar-se mais rápidas, mas não se tornaram mais rápidas à mesma taxa que a parte de modelação de machine learning se tornou mais rápida.
+
+Assim, pegamos num processo, e uma parte dele torna-se muito mais rápida. O que estou a ver é que a prototipagem é realmente rápida, mas por vezes levar um protótipo para uma produção robusta e fiável com guardrails e assim — esses outros passos ainda demoram algum tempo. Mas a dinâmica interessante que estou a ver é que o facto de a parte de machine learning ser tão rápida está a colocar muita pressão nas organizações para acelerar todas essas outras partes também.
+
+Isso tem sido um progresso emocionante em termos de como o desenvolvimento de machine learning está a acelerar as coisas.
+
+## Mover Rápido e Ser Responsável
+
+Penso que o mantra "Mover rápido e partir coisas" ganhou má reputação porque, bem, partiu coisas. Algumas pessoas interpretam isto como significando que não devemos mover-nos rápido, mas discordo disso. Penso que o melhor mantra é "Mover rápido e ser responsável."
+
+Estou a ver muitas equipas capazes de prototipar rapidamente, avaliar e testar de forma robusta — sem lançar nada para o mundo mais amplo que possa causar danos ou prejuízos significativos. Estou a encontrar equipas inteligentes capazes de construir muito rapidamente e mover-se muito depressa, mas também a fazê-lo de uma forma muito responsável. Acho isto estimulante — que se possam construir coisas e lançar coisas de forma responsável muito mais rapidamente do que nunca.
+
+## Fluxos de Trabalho de IA Agente
+
+Agora, há muita coisa a acontecer na IA, e de todas as coisas que estão a acontecer na IA em termos de tendências técnicas, a tendência que mais me entusiasma são os fluxos de trabalho de IA agente. Assim, se me perguntassem qual é a tecnologia de IA mais importante a que devemos prestar atenção, diria que é a IA agente.
+
+Quando comecei a dizer isto no início deste ano, era uma afirmação um pouco controversa, mas agora o termo "agentes de IA" tornou-se tão amplamente utilizado por pessoas técnicas e não técnicas que se tornou um pouco num termo de moda. Assim, deixem-me partilhar convosco como vejo os agentes de IA e porque penso que são importantes.
+
+Abordando isto de uma perspetiva técnica, a forma como a maioria de nós usa modelos de linguagem grandes hoje é com o que se chama prompting de zero-shot. Isso significa aproximadamente que lhe pedimos — damos-lhe um prompt — para escrever um ensaio ou uma saída para nós. É um pouco como se estivéssemos a ir a uma pessoa, ou neste caso a uma IA, e a pedir-lhe para escrever um ensaio para nós, começando da primeira palavra, escrevendo da primeira palavra até à última palavra, tudo de uma vez, sem nunca usar o backspace — simplesmente do início ao fim assim.
+
+Acontece que as pessoas — nós não fazemos a nossa melhor escrita desta forma. Mas apesar da dificuldade de ser forçado a escrever desta forma, os modelos de linguagem grandes fazem, sabem, não mal — bastante bem.
+
+Aqui está como é um fluxo de trabalho agente: para gerar um ensaio, pedimos a uma IA para primeiro escrever um esboço do ensaio, perguntar se precisa de fazer alguma pesquisa na web, e se sim, vamos descarregar algumas páginas web e colocá-las no contexto do modelo de linguagem grande. Depois, vamos escrever o primeiro rascunho, ler o primeiro rascunho e criticá-lo.
+
+# Fluxos de Trabalho Agentes: Melhorar o Desempenho Através de Processos Iterativos
+
+Ao rever rascunhos e tarefas semelhantes, um fluxo de trabalho agente envolve um ciclo de reflexão, pesquisa, revisão e, em seguida, retorno a mais reflexão e pesquisa. Este ciclo iterativo, embora demorado, leva a resultados de trabalho significativamente melhores.
+
+Em algumas equipas com as quais trabalho, aplicamos este fluxo de trabalho agente para processar documentos legais complexos, auxiliar em diagnósticos de saúde e lidar com papeladas intrincadas de conformidade governamental. Esta abordagem frequentemente produz resultados superiores em comparação com métodos tradicionais.
+
+Uma área em que quero focar nesta apresentação é o desenvolvimento de IA visual, onde os fluxos de trabalho agentes nos permitem processar dados de imagem e vídeo. Vou aprofundar este tópico mais tarde.
+
+## Benchmarks que Demonstram a Eficácia dos Fluxos de Trabalho Agentes
+
+Existem benchmarks que mostram que os fluxos de trabalho agentes entregam resultados muito melhores. Um benchmark notável é o Human Eval Benchmark da OpenAI, que mede a capacidade dos grandes modelos de linguagem para resolver puzzles de codificação.
+
+Dados recolhidos pela minha equipa revelam que neste benchmark (POS K Benchmark, POS K Metric), o GPT-3.5 obteve 48% de precisão. O GPT-4 mostrou uma melhoria significativa com 67%. No entanto, o salto do GPT-3.5 para o GPT-4 é ofuscado pela melhoria observada quando o GPT-3.5 é usado dentro de um fluxo de trabalho agente, alcançando mais de 95% de precisão. O GPT-4 com um fluxo de trabalho agente também apresenta um desempenho substancialmente melhor.
+
+## Quatro Padrões de Design Principais nos Fluxos de Trabalho Agentes
+
+Na forma como os construtores implementam o raciocínio agente ou fluxos de trabalho nas suas aplicações, existem quatro padrões de design principais:
+
+1. **Reflexão**
+2. **Uso de Planeamento**
+3. **Colaboração Multiagente**
+4. **Desmistificação dos Fluxos de Trabalho Agentes**
+
+Os fluxos de trabalho agentes podem parecer um tanto misteriosos até que se leia o código. Deixe-me explicar brevemente o que estes fluxos de trabalho envolvem.
+
+### Reflexão na Geração de Código
+
+Por exemplo, na reflexão, posso começar por solicitar a um agente codificador (um grande modelo de linguagem) com uma mensagem como: "O teu papel é ser um codificador. Por favor, escreve código para uma determinada tarefa." O modelo gera código, que é então copiado e colado de volta num prompt pedindo-lhe para criticar o código. O mesmo modelo pode encontrar problemas ou sugerir melhorias. Este processo pode incluir a execução de testes unitários e o fornecimento de feedback, levando a mais iterações de código.
+
+Este tipo de fluxo de trabalho de reflexão não é mágico e não resolve todos os problemas, mas frequentemente eleva o desempenho base. Também antecipa o planeamento ou fluxos de trabalho multiagente, onde um modelo desempenha o papel de codificador e outro revê o código, resultando em melhorias de desempenho.
+
+### Uso de Planeamento em Chamadas de Função
+
+O segundo padrão de design principal é o uso de planeamento. Aqui, um grande modelo de linguagem pode ser solicitado a gerar um pedido para uma chamada de API, decidindo quando precisa de pesquisar na web, executar código, emitir um reembolso ao cliente, enviar um email ou consultar uma entrada de calendário. Isto expande as capacidades dos fluxos de trabalho agentes.
+
+### Padrão de Design de Planeamento em Tarefas Complexas
+
+No planeamento, dado um pedido complexo como gerar uma imagem de uma rapariga a ler um livro, um modelo de linguagem pode usar um modelo de pose aberta para detetar a pose, gerar a imagem, descrevê-la e, em seguida, usar TTS para gerar áudio. Isto envolve o modelo a escolher uma sequência de ações para executar uma tarefa complexa.
+
+### Colaboração Multiagente
+
+Por último, a colaboração multiagente ocorre quando, em vez de solicitar a um modelo para fazer uma coisa, ele é solicitado a desempenhar diferentes papéis em diferentes momentos. Diferentes agentes simulados interagem para resolver uma tarefa. Este padrão de design demonstrou melhorias significativas de desempenho para várias tarefas. É análogo a executar múltiplos processos numa CPU, dividindo tarefas em subtarefas para maior eficiência.
+
+## A Ascensão de Agentes Baseados em Modelos Multimodais
+
+Estou particularmente entusiasmado com a ascensão não apenas de agentes baseados em grandes modelos de linguagem, mas também de agentes baseados em grandes modelos multimodais. Por exemplo, dada uma imagem, um grande modelo multimodal pode realizar previsões zero-shot, o que é semelhante a olhar para a imagem e fornecer uma saída. Para tarefas simples de imagem, como contar o número de corredores, isto funciona bem.
+
+No entanto, como com agentes baseados em grandes modelos de linguagem, os agentes baseados em modelos multimodais desempenham-se melhor com um fluxo de trabalho iterativo. Eles podem abordar o problema passo a passo: detetar os rostos, detetar os números e juntar tudo. Isto permite ao agente planear, testar e articular código para realizar tarefas mais complexas.
+
+## Demonstração: Fluxos de Trabalho Agentes para Tarefas de IA Visual
+
+Para ilustrar, gostaria de mostrar uma demonstração do trabalho feito por Dan Malone e por mim, juntamente com a equipa H AI, na construção de fluxos de trabalho agentes para tarefas de IA visual. No meu portátil, tenho uma imagem de um jogo de futebol. Vou solicitar ao modelo que conte os jogadores na imagem.
+
+Se não tiveres a certeza de como solicitar, após carregar uma imagem, um pequeno ícone de lâmpada fornece sugestões de prompts que podes usar.
+
+# Vision Agent: Revolucionando o Processamento de Dados Visuais em AI
+
+Vamos explorar como o Vision Agent pode transformar a forma como processamos dados visuais.
+
+## Contagem de Jogadores em Campo
+
+Primeiro, consideremos um cenário em que precisamos contar o número de jogadores num campo de futebol. Este processo envolve a execução de um código que demora alguns minutos a analisar e gerar um resultado preciso. A complexidade surge porque não queremos contar jogadores em segundo plano — apenas os que estão em primeiro plano.
+
+Já executei isto anteriormente, por isso vamos diretos ao resultado. O código selecionou sete jogadores em campo. Vamos verificar: 1, 2, 3, 4, 5, 6, 7. Ao ampliar a saída do modelo, confirmamos que a contagem está correta.
+
+Um dos resultados mais interessantes deste processo é a geração de código Python. Este código pode ser executado repetidamente numa grande coleção de imagens. Esta capacidade é particularmente valiosa para empresas e equipas que têm grandes quantidades de dados visuais de AI armazenados, mas que têm tido dificuldades em extrair insights significativos.
+
+Para muitas pequenas equipas ou grandes empresas com vastos dados visuais, o Vision Agent permite-lhes tirar partido de dados anteriormente armazenados em blob storage e obter valor real deles. Isto representa uma transformação significativa na AI.
+
+## Análise de Vídeos de Jogos de Futebol
+
+Aqui está outro exemplo: dado um vídeo de um jogo de futebol, a tarefa é dividir o vídeo em clips de 5 segundos e identificar o clip em que um golo é marcado. O Vision Agent gera código para avaliar o vídeo e devolve o clip relevante.
+
+Por exemplo, pode identificar um golo marcado por volta dos 10-15 segundos e extrair os frames associados. Isto é incrivelmente útil para processar dados de vídeo de forma eficiente.
+
+## Geração de Metadados para Clips de Vídeo
+
+Outra funcionalidade poderosa é a capacidade de dividir um vídeo em segmentos mais pequenos, descrever cada segmento e armazenar a informação num Pandas DataFrame. Estes metadados podem depois ser armazenados em plataformas como o Snowflake, permitindo o desenvolvimento de outras aplicações sobre eles.
+
+O Vision Agent escreve o código para construir estes metadados, que podem ser usados para indexar uma coleção de vídeos. Por exemplo, se pesquisar por "esquiador no ar", o sistema mostrará clips com alta similaridade, marcados a verde na timeline.
+
+## Aplicações Práticas
+
+Vamos explorar uma aplicação prática. Suponha que tem uma coleção de vídeos e quer indexá-los para uma navegação fácil. Usando o Vision Agent, pode dividir o vídeo em segmentos, armazenar os metadados e depois pesquisar por conteúdo específico. Por exemplo, pesquisar por "lobo cinzento à noite" mostrará clips relevantes, com a timeline a indicar onde o lobo cinzento aparece.
+
+Outro exemplo divertido é a identificação de bagagem. Se tiver muita bagagem preta mas quiser encontrar a que tem uma correia arco-íris, o Vision Agent pode ajudá-lo a localizá-la rapidamente.
+
+## O Futuro da AI: Fluxos de Trabalho Agentes
+
+Em termos de oportunidades de AI, os fluxos de trabalho agentes estão a mudar o stack de AI. Há uma nova camada emergente de orquestração agentes, tornando mais fácil para os developers construírem aplicações. O Vision Agent é uma contribuição para esta camada, simplificando o processo de construção de aplicações de AI visual.
+
+### Tendências Chave de AI a Observar
+
+1. **Velocidade de Geração de Tokens**: Os fluxos de trabalho agentes geram muitos tokens. Esforços para acelerar a geração de tokens, incluindo avanços em semicondutores e software, vão melhorar estes fluxos de trabalho.
+
+2. **Modelos de Linguagem Grandes Otimizados**: Os modelos de linguagem grandes de hoje estão otimizados para responder a perguntas humanas. No entanto, os fluxos de trabalho agentes requerem modelos ajustados especificamente para o uso de ferramentas, o que está a tornar-se cada vez mais comum.
+
+3. **Crescente Importância da Engenharia de Dados**: Com a capacidade de processar dados não estruturados como texto, imagens e vídeo, a engenharia de dados está a tornar-se mais crítica. Gerir dados não estruturados e os seus metadados é um foco principal para muitas empresas.
+
+4. **Revolução no Processamento de Imagens**: Enquanto o processamento de texto já revolucionou muitos campos, o processamento de imagens está nos seus estágios iniciais. À medida que amadurece, as empresas poderão extrair mais valor dos dados visuais, expandindo significativamente o leque de aplicações possíveis.
+
+Em conclusão, o Vision Agent e tecnologias semelhantes estão a tornar mais fácil do que nunca construir aplicações que processam e extraem valor de dados visuais. Este é um momento emocionante para a AI, com inúmeras oportunidades no horizonte.
+
+# Conclusão: O Momento Atual para Desenvolvedores
+
+Este é um momento excelente para ser desenvolvedor. A IA generativa está a permitir-nos aprender e experimentar mais rapidamente do que nunca, expandindo o leque de possibilidades. Existem inúmeras novas aplicações que podemos criar agora, tanto na área de IA visual como noutras áreas, que antes eram impossíveis.
+
+Se estiver interessado em ver as demonstrações de IA visual que apresentei, visite [va.landing.ai](https://va.landing.ai). Lá, poderá experimentar exatamente as mesmas demonstrações que mostrei, obter o código e executá-lo nas suas próprias aplicações.
+
+Com isto, gostaria de agradecer a todos e pedir que se juntem a mim para receber de volta ao palco a Elsa. Muito obrigado!
+
+---

kb-processor/src/web/uploads/output_20250107_231907.md

@@ -0,0 +1,223 @@
+# Andrew Ng Explores The Rise Of AI Agents And Agentic Reasoning | BUILD 2024 Keynote
+
+Canal: Snowflake Inc.
+Data: 20241119
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=KrRD7r7y7NY
+Idioma: English (auto-generated)
+
+# Bem-vindo, Andrew: O Futuro das Oportunidades da IA
+
+[Aplausos]
+
+Obrigado! É um momento excelente para ser um construtor. Estou entusiasmado por estar de volta ao Snowflake Build. Hoje, gostaria de partilhar onde penso que se encontram algumas das maiores oportunidades da IA.
+
+## A IA como a Nova Eletricidade
+
+Já me devem ter ouvido dizer que considero a IA como a nova eletricidade. Isto porque a IA é uma tecnologia de propósito geral, tal como a eletricidade. Se vos perguntar: "Para que serve a eletricidade?", é sempre difícil responder porque serve para tantas coisas diferentes. De forma semelhante, a nova tecnologia de IA está a criar um vasto conjunto de oportunidades para construirmos novas aplicações que antes não eram possíveis.
+
+## A Pilha da IA
+
+As pessoas perguntam-me frequentemente: "Andrew, onde estão as maiores oportunidades da IA?" Isto é o que eu considero como a pilha da IA:
+
+- **Semicondutores**: No nível mais baixo.
+- **Infraestrutura Cloud**: Incluindo, claro, o Snowflake.
+- **Modelos Base e Treinadores**: No topo da infraestrutura cloud.
+
+Muito do entusiasmo mediático, especialmente nas redes sociais, tem-se focado nestas novas camadas tecnológicas. Não há mal nenhum nisso, mas penso que, quase por definição, há outra camada da pilha que tem de funcionar ainda melhor: a **camada de aplicações**. Precisamos de aplicações para gerar ainda mais valor e receita para suportar os fornecedores de tecnologia abaixo.
+
+## A Importância das Aplicações de IA
+
+Passo muito do meu tempo a pensar em aplicações de IA, e acredito que é aí que estarão muitas das melhores oportunidades para construir coisas novas. Uma das tendências que tem vindo a crescer nos últimos anos, em grande parte devido à IA generativa, é o desenvolvimento cada vez mais rápido de modelos de machine learning.
+
+### Desenvolvimento Mais Rápido de Modelos com IA Generativa
+
+A IA generativa está a permitir-nos construir coisas mais rapidamente do que nunca. Tomemos o problema de construir uma ferramenta de análise de sentimentos, por exemplo. O fluxo de trabalho típico usando aprendizagem supervisionada pode demorar um mês para obter dados rotulados, alguns meses para treinar o modelo de IA e mais alguns meses para o implementar num serviço cloud. Durante muito tempo, sistemas de IA valiosos podiam demorar seis a 12 meses a serem construídos por boas equipas de IA.
+
+Mas com a IA generativa, há certas classes de aplicações onde se pode escrever um prompt em dias e implementá-lo também em dias. Isto significa que aplicações que antes demoravam meses a construir podem agora ser construídas em talvez 10 dias. Isto abre a oportunidade de experimentar novos protótipos e lançar novos produtos de IA.
+
+### Experimentação e Iteração Rápidas
+
+A experimentação rápida está a tornar-se um caminho mais promissor para a invenção. Anteriormente, se demorasse seis meses a construir algo, tínhamos de estudá-lo, garantir que havia procura do utilizador e documentá-lo antes de gastar todo esse esforço para o construir. Agora, para equipas de IA em movimento rápido, vejo um padrão de design onde se pode montar um protótipo num fim de semana, construir 20 protótipos e ver o que resulta. Se 18 deles não funcionarem, ficamos com o que funciona. A iteração rápida e a experimentação rápida estão a tornar-se um novo caminho para inventar novas experiências de utilizador.
+
+### O Gargalo das Avaliações
+
+Uma implicação interessante é que as avaliações (ou "evals" para abreviar) estão a tornar-se um gargalo maior na forma como construímos coisas. No mundo da aprendizagem supervisionada, se estivermos a recolher 10.000 pontos de dados para treinar um modelo, recolher mais 1.000 para testes não era problema—apenas um aumento de 10% no custo. Mas para muitas aplicações baseadas em modelos de linguagem grandes, se não houver necessidade de dados de treino, recolher 1.000 exemplos de teste pode parecer um enorme gargalo.
+
+O novo fluxo de trabalho de desenvolvimento muitas vezes parece que estamos a construir e a recolher dados mais em paralelo do que sequencialmente. Construímos um protótipo, e à medida que se torna mais importante e a robustez e fiabilidade se tornam mais críticas, gradualmente construímos esse conjunto de testes em paralelo. Vejo inovações emocionantes ainda por vir na forma como construímos avaliações.
+
+### A Velocidade do Protótipo vs. Produção
+
+A prototipagem de machine learning tornou-se muito mais rápida, mas construir uma aplicação de software envolve muitos passos: O produto funciona? O design funciona? A integração do software funciona? Há muito trabalho de canalização envolvido, e após a implementação, há DevOps e LOps. Algumas destas outras peças estão a tornar-se mais rápidas, mas não ao mesmo ritmo que a parte de modelação de machine learning.
+
+Assim, enquanto a prototipagem é realmente rápida, levar um protótipo para uma produção robusta e fiável com guardrails ainda demora algum tempo. A dinâmica interessante que estou a ver é que a velocidade do machine learning está a colocar muita pressão nas organizações para acelerar todas essas outras partes também.
+
+## Mover Rápido e Ser Responsável
+
+Em termos de como o desenvolvimento de machine learning está a acelerar as coisas, penso que o mantra "mover rápido e partir coisas" ganhou má reputação porque, bem, partiu coisas. Algumas pessoas interpretam isto como significando que não devemos mover-nos rápido, mas discordo. Penso que o melhor mantra é "mover rápido e ser responsável". Estou a ver muitas equipas capazes de prototipar rapidamente, avaliar e testar robustamente sem enviar nada para o mundo mais amplo que possa causar danos ou prejuízos significativos. Equipas inteligentes estão a construir rapidamente e a mover-se rápido, mas também a fazer isto de uma forma muito responsável. Acho isto estimulante—que se pode construir e enviar coisas de forma responsável muito mais rápido do que nunca.
+
+## A Ascensão dos Fluxos de Trabalho de IA Agente
+
+Agora, há muita coisa a acontecer na IA, e de todas as tendências técnicas, a que mais me entusiasma são os **fluxos de trabalho de IA agente**. Se me perguntassem qual é a tecnologia de IA mais importante a prestar atenção, diria que é a IA agente.
+
+Quando comecei a dizer isto no início do ano, era uma afirmação um pouco controversa. Mas agora, o termo "agentes de IA" tornou-se tão amplamente utilizado por pessoas técnicas e não técnicas que se tornou um pouco num termo de moda. Deixem-me partilhar convosco como vejo os agentes de IA e porque penso que são importantes.
+
+### Prompting Zero-Shot vs. Fluxos de Trabalho Agentes
+
+De uma perspetiva técnica, a maioria de nós usa modelos de linguagem grandes hoje com o que se chama **prompting zero-shot**. Isto significa, grosso modo, que damos um prompt—como "escreve um ensaio"—e ele gera uma saída do início ao fim de uma só vez, sem nunca usar a tecla de retrocesso. É como pedir a uma pessoa para escrever um ensaio desde a primeira palavra até à última palavra de uma só vez.
+
+As pessoas não fazem a sua melhor escrita desta forma, mas apesar da dificuldade, os modelos de linguagem grandes fazem um trabalho bastante bom. Aqui está como um fluxo de trabalho agente se parece: Para gerar um ensaio, pedimos a uma IA para primeiro escrever um esboço do ensaio, fazer alguma pesquisa na web se necessário, descarregar páginas web relevantes e colocá-las no contexto do modelo de linguagem grande. Depois, escreve o primeiro rascunho, critica-o e itera até que o resultado final seja produzido.
+
+---
+
+Isto é apenas o início do que é possível com a IA, e estou entusiasmado para ver onde estas tendências nos levarão. Obrigado! [Aplausos]
+
+# Fluxos de Trabalho Agentes: Revolucionando o Desempenho da IA
+
+## Introdução aos Fluxos de Trabalho Agentes
+
+Ao rever um rascunho ou realizar tarefas complexas, o fluxo de trabalho envolve frequentemente um processo cíclico de pensar, pesquisar, rever e repetir. Este ciclo iterativo, embora demorado, melhora significativamente a qualidade do resultado. Em várias equipas com as quais colaboro, aplicamos este **fluxo de trabalho agente** para lidar com tarefas intrincadas, como o processamento de documentos legais complexos, assistência em diagnósticos de saúde e gestão de documentação de conformidade governamental. Esta abordagem produz consistentemente resultados superiores em comparação com métodos tradicionais.
+
+## O Poder dos Fluxos de Trabalho Agentes
+
+Uma área que me entusiasma particularmente discutir é a **IA visual**, onde os fluxos de trabalho agentes nos permitem processar dados de imagem e vídeo de forma mais eficaz. Mas antes de mergulharmos nisso, vamos explorar alguns benchmarks que destacam a eficácia dos fluxos de trabalho agentes.
+
+### Insights de Benchmark
+
+O **Benchmark HumanEval**, desenvolvido pela OpenAI, mede a capacidade dos grandes modelos de linguagem para resolver puzzles de codificação. A minha equipa recolheu dados sobre este benchmark, e os resultados são impressionantes:
+
+- O **GPT-3.5** alcançou uma taxa de precisão de 48%.
+- O **GPT-4** mostrou uma melhoria significativa, atingindo 67%.
+- No entanto, o salto mais impressionante ocorreu quando o **GPT-3.5** foi utilizado com um **fluxo de trabalho agente**, alcançando até **95% de precisão**. Da mesma forma, o **GPT-4** com um fluxo de trabalho agente também teve um desempenho muito melhor.
+
+Estes resultados sublinham o potencial transformador dos fluxos de trabalho agentes no aprimoramento do desempenho da IA.
+
+---
+
+## Quatro Padrões de Design Principais para Fluxos de Trabalho Agentes
+
+Para desmistificar os fluxos de trabalho agentes, vamos decompor os quatro padrões de design principais que os desenvolvedores utilizam para os construir:
+
+### 1. Reflexão
+A reflexão envolve solicitar a um modelo de linguagem (LM) que critique e melhore o seu próprio output. Por exemplo:
+- Comece por pedir ao LM para gerar código para uma tarefa específica.
+- Copie o código gerado de volta para o prompt e peça ao LM para o criticar.
+- Utilize o feedback para solicitar ao LM que refine o código.
+- Opcionalmente, incorpore testes unitários para um refinamento adicional.
+
+Este processo iterativo frequentemente eleva o desempenho de base para um nível superior. A reflexão também antecipa **fluxos de trabalho multiagentes**, onde um LM desempenha o papel de codificador enquanto outro atua como crítico.
+
+### 2. Utilização de Ferramentas
+Neste padrão de design, o LM é solicitado a gerar pedidos para chamadas de API. Por exemplo, pode decidir:
+- Pesquisar na web.
+- Executar código.
+- Emitir um reembolso ao cliente.
+- Enviar um email ou consultar uma entrada de calendário.
+
+Esta capacidade de fazer **chamadas de função** expande significativamente as capacidades dos fluxos de trabalho agentes.
+
+### 3. Planeamento
+O planeamento envolve a decomposição de tarefas complexas numa sequência de ações. Por exemplo:
+- Gerar uma imagem de uma rapariga a ler um livro.
+- Utilizar um modelo de pose aberta para detetar a pose.
+- Descrever a imagem.
+- Utilizar text-to-speech (TTS) para gerar áudio.
+
+Ao planear passo a passo, o LM pode lidar eficazmente com tarefas intrincadas.
+
+### 4. Colaboração Multiagente
+Este padrão envolve solicitar a um único LM que desempenhe múltiplos papéis, simulando interações entre diferentes agentes. Por exemplo:
+- Um agente pode especializar-se em codificação.
+- Outro pode focar-se na revisão e crítica do código.
+
+Esta abordagem espelha como múltiplos processos numa CPU trabalham em conjunto para alcançar um objetivo. Muitas equipas demonstraram melhorias significativas de desempenho utilizando este padrão de design.
+
+---
+
+## A Ascensão dos Agentes Multimodais
+
+Embora os grandes modelos de linguagem (LLMs) tenham estado na vanguarda dos fluxos de trabalho agentes, estou particularmente entusiasmado com a ascensão dos **grandes modelos multimodais (LMMs)**. Estes modelos podem processar não apenas texto, mas também imagens e vídeos.
+
+### Exemplo: Tarefas de IA Visual
+Considere uma imagem de um jogo de futebol. Utilizando um agente multimodal, pode:
+- Detetar rostos e números na imagem.
+- Planear, testar e refinar o output passo a passo.
+- Gerar uma análise detalhada ou até escrever código para processar a imagem.
+
+Esta abordagem de **fluxo de trabalho agente** permite resultados mais complexos e precisos em comparação com o prompting zero-shot simples.
+
+---
+
+## Demonstração: Fluxos de Trabalho Agentes em Ação
+
+Para ilustrar isto, deixem-me partilhar uma demonstração em que Dan Malone e eu, juntamente com a equipa HAI, temos estado a trabalhar. Vamos utilizar uma imagem de um jogo de futebol e solicitar ao agente para contar os jogadores. Ao aproveitar os fluxos de trabalho agentes, o agente pode:
+- Detetar os jogadores.
+- Planear e executar o processo de contagem.
+- Entregar resultados precisos.
+
+Isto mostra o poder de combinar **IA visual** com **fluxos de trabalho agentes** para resolver tarefas do mundo real.
+
+---
+
+## Conclusão
+
+Os fluxos de trabalho agentes, com os seus quatro padrões de design principais—reflexão, utilização de ferramentas, planeamento e colaboração multiagente—abrem um vasto espaço para inovação. Permitem-nos construir agentes inteligentes e ricos, capazes de tarefas que eram inimagináveis há apenas um ano. À medida que continuamos a explorar o potencial dos **agentes multimodais**, as possibilidades para aplicações de IA são verdadeiramente ilimitadas.
+
+# Vision Agent: Revolucionando as Aplicações de IA Visual
+
+Vamos explorar como o Vision Agent funciona e as suas potenciais aplicações.
+
+## Contagem de Jogadores em Campo
+
+O processo começa por contar o número de jogadores em campo. Esta tarefa inicia um processo que decorre durante alguns minutos, gerando código para contar com precisão os jogadores. A complexidade reside em garantir que apenas os jogadores em primeiro plano são contados, e não os que estão em segundo plano.
+
+Já executei isto anteriormente, por isso podemos saltar diretamente para o resultado. O código selecionou sete jogadores em campo e, ao ampliar a imagem, podemos confirmar que a contagem está correta: 1, 2, 3, 4, 5, 6, 7.
+
+O output também inclui código Python que pode ser executado repetidamente numa grande coleção de imagens. Isto é particularmente interessante para empresas e equipas com grandes quantidades de dados de IA visual. Até agora, extrair valor destes dados tem sido um desafio. O Vision Agent permite que estas equipas utilizem dados previamente armazenados e obtenham valor real a partir deles, marcando uma transformação significativa na IA.
+
+## Processamento de Vídeo: Identificação de Golos no Futebol
+
+Eis outro exemplo: dado um vídeo de um jogo de futebol, a tarefa consiste em dividir o vídeo em clips de 5 segundos e identificar o clip onde é marcado um golo. O Vision Agent gera código para avaliar o vídeo e devolve o resultado. Neste caso, identifica um golo por volta do minuto 10:15 e extrai os frames relevantes. Esta capacidade é incrivelmente útil para processar dados de vídeo.
+
+## Geração de Metadados para Clips de Vídeo
+
+O Vision Agent também pode dividir um vídeo em segmentos de 6 segundos, descrever cada segmento e armazenar a informação num Pandas DataFrame juntamente com o nome do clip, o tempo de início e o tempo de fim. Estes metadados podem então ser armazenados em plataformas como o Snowflake para construir outras aplicações em cima deles.
+
+## Construção de uma App de Demonstração com o Vision Agent
+
+Utilizando as capacidades de geração de código do Vision Agent, a minha equipa na Landing AI construiu uma app de demonstração que indexa uma coleção de vídeos. Por exemplo, pesquisar por "skier airborne" mostra clips com alta similaridade, marcados a verde na linha do tempo. Esta app demonstra como os dados de vídeo podem ser facilmente indexados e navegados.
+
+Outro exemplo é pesquisar por "gray wolf at night". A app destaca as partes relevantes do vídeo, facilitando a localização de conteúdo específico. Esta funcionalidade não só é prática como também divertida de utilizar.
+
+## Identificação de Bagagem Específica
+
+O Vision Agent pode até ajudar a identificar itens específicos, como bagagem. Por exemplo, pesquisar por "black luggage with rainbow strap" entre muitos itens de bagagem preta pode rapidamente identificar o item desejado. Isto mostra a versatilidade e o potencial do Vision Agent em várias aplicações.
+
+## O Futuro da IA: Fluxos de Trabalho Agentes
+
+Em termos de oportunidades de IA, os fluxos de trabalho agentes estão a mudar o stack de IA. Uma nova camada emergente de orquestração agentes, como o LangChain, está a facilitar a construção de aplicações por parte dos desenvolvedores. O Vision Agent contribui para isto ao simplificar o processo de construção de aplicações de IA visual, permitindo que as empresas extraiam valor dos seus dados de imagem e vídeo de forma mais eficiente.
+
+## Principais Tendências de IA a Observar
+
+1. **Velocidade de Geração de Tokens**: Esforços para acelerar a geração de tokens, incluindo avanços em semicondutores e software, irão melhorar os fluxos de trabalho agentes.
+2. **Utilização de Ferramentas em LLMs**: Os grandes modelos de linguagem estão cada vez mais a ser ajustados para suportar a utilização de ferramentas, expandindo as suas capacidades para além de responder a consultas humanas.
+3. **Engenharia de Dados para Dados Não Estruturados**: A importância da engenharia de dados está a aumentar, particularmente para gerir dados não estruturados como texto, imagens e vídeo.
+4. **Revolução no Processamento de Imagens**: Enquanto o processamento de texto já revolucionou a IA, o processamento de imagens está no horizonte, prometendo desbloquear ainda mais valor a partir de dados visuais.
+
+O Vision Agent é uma ferramenta poderosa que reduz a barreira para a construção de aplicações sofisticadas de IA visual, tornando mais fácil do que nunca extrair valor de dados visuais.
+
+# A Era de Ouro para Desenvolvedores
+
+Este é um momento extraordinário para ser um desenvolvedor. A IA generativa está a permitir-nos aprender e experimentar mais rapidamente do que nunca. A inteligência artificial está a expandir o leque de possibilidades, e existem tantas novas aplicações que podemos criar — tanto em IA visual como noutras áreas — que simplesmente não eram viáveis anteriormente.
+
+## Experimente Você Mesmo
+
+Se ficou interessado pelos demos de IA visual que mostrei, visite [va.landing.ai](https://va.landing.ai). Lá encontrará exatamente os mesmos exemplos que demonstrei, poderá testá-los online, obter o código e executá-lo nas suas próprias aplicações.
+
+## Agradecimentos
+
+Gostaria de agradecer a todos pela atenção. E agora, por favor, recebam comigo a Elsa de volta ao palco. Obrigado!
+
+---

kb-processor/src/web/uploads/output_20250107_232230.md

@@ -0,0 +1,220 @@
+# Andrew Ng Explores The Rise Of AI Agents And Agentic Reasoning | BUILD 2024 Keynote
+
+Canal: Snowflake Inc.
+Data: 20241119
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=KrRD7r7y7NY
+Idioma: English (auto-generated)
+
+# Bem-vindo, Andrew!
+
+[**Aplausos**]
+
+É um ótimo momento para ser um construtor. Estou entusiasmado por estar de volta ao **Snowflake Build**. Hoje, gostaria de partilhar onde vejo as maiores oportunidades da **IA**.
+
+Já me deve ter ouvido dizer que acredito que a **IA é a nova eletricidade**. Isto porque a IA é uma tecnologia de propósito geral, tal como a eletricidade. Se perguntar para que serve a eletricidade, é difícil responder, pois é útil para tantas coisas diferentes. A nova tecnologia de IA está a criar um enorme conjunto de oportunidades para construirmos aplicações que antes não eram possíveis.
+
+Muitas pessoas perguntam-me: "Andrew, onde estão as maiores oportunidades em IA?" É a isto que chamo de **pilha da IA**. No nível mais baixo estão os semicondutores. A seguir, temos a infraestrutura em cloud, incluindo, claro, o **Snowflake**. Acima disso, estão muitos dos modelos base e os seus treinadores.
+
+Acontece que grande parte do hype dos media e do buzz nas redes sociais tem-se concentrado nestas camadas da pilha, especialmente nas novas camadas tecnológicas. Quando surge uma nova tecnologia, como a **IA generativa**, o foco está nestas camadas. E não há nada de errado nisso. Mas, por definição, há outra camada da pilha que precisa funcionar ainda melhor: a **camada de aplicações**. Precisamos que as aplicações gerem ainda mais valor e receita para que possamos pagar os fornecedores de tecnologia abaixo.
+
+Por isso, passo muito tempo a pensar em aplicações de IA e acredito que é aí que estão as melhores oportunidades para construir coisas novas.
+
+## Tendências em Desenvolvimento de IA
+
+Uma das tendências que tem crescido nos últimos anos, em grande parte devido à IA generativa, é o desenvolvimento **rápido e cada vez mais acelerado** de modelos de machine learning. Em particular, a IA generativa permite-nos construir coisas mais rapidamente do que nunca.
+
+Vamos pegar no problema de construir um **classificador de sentimentos**, por exemplo. O objetivo é analisar um texto e determinar se tem uma conotação positiva ou negativa, como em monitorização de reputação. Um fluxo de trabalho típico usando aprendizagem supervisionada poderia levar um mês para recolher dados rotulados, alguns meses para treinar o modelo e mais alguns meses para implementá-lo num serviço em cloud. Durante muito tempo, sistemas de IA valiosos levavam de seis a doze meses para serem construídos por boas equipas de IA.
+
+Não há nada de errado com isto. Muitas pessoas criam sistemas de IA valiosos desta forma. Mas, com a IA generativa, há certas classes de aplicações onde se pode escrever um **prompt** em dias e implementá-lo em questão de dias também. Isto significa que muitas aplicações que antes levavam meses para serem construídas agora podem ser feitas em cerca de dez dias.
+
+Isto abre a oportunidade de experimentar, construir novos protótipos e lançar novos produtos de IA. A **prototipagem rápida** está a tornar-se um caminho mais promissor para a inovação. Antes, se levava seis meses para construir algo, precisávamos estudar, garantir a procura do utilizador, documentar e depois gastar todo esse esforço para construir. Agora, equipas ágeis de IA podem construir 20 protótipos num fim de semana e ver o que funciona. Se 18 deles não derem certo, descartamos e focamo-nos no que funciona.
+
+## Avaliações e Desenvolvimento Paralelo
+
+Uma implicação interessante é que as **avaliações** (ou "evals") estão a tornar-se um gargalo maior no processo de construção. No mundo da aprendizagem supervisionada, se já estava a recolher 10.000 pontos de dados para treinar um modelo, recolher mais 1.000 para testes era um aumento de custo de apenas 10%. Mas, em muitas aplicações baseadas em modelos de linguagem grandes, se não há necessidade de dados de treinamento, recolher 1.000 exemplos de teste pode parecer um grande gargalo.
+
+O novo fluxo de trabalho de desenvolvimento muitas vezes parece que estamos a construir e a recolher dados em paralelo, em vez de sequencialmente. Construímos um protótipo e, à medida que se torna mais importante e a robustez e fiabilidade se tornam críticas, gradualmente construímos o conjunto de testes em paralelo. Ainda vejo muitas inovações emocionantes em como construímos estas avaliações.
+
+## Prototipagem Rápida vs. Produção
+
+A prototipagem de machine learning tornou-se muito mais rápida, mas construir uma aplicação de software envolve muitas etapas: o produto funciona? O design funciona? A integração do software funciona? Há muita "encanação" envolvida. Após a implementação, há **DevOps** e **MLOps**. Algumas destas outras partes estão a tornar-se mais rápidas, mas não na mesma taxa que a modelagem de machine learning.
+
+O que estou a ver é que a prototipagem é realmente rápida, mas levar um protótipo para uma produção robusta e fiável, com guardrails e tudo mais, ainda leva algum tempo. O interessante é que a velocidade da modelagem de machine learning está a pressionar as organizações a acelerar todas estas outras partes também. Isto tem sido um progresso emocionante.
+
+## Mova-se Rápido, mas com Responsabilidade
+
+Acho que o mantra **"mova-se rápido e quebre coisas"** ganhou uma má reputação porque, bem, quebrou coisas. Algumas pessoas interpretam isto como um sinal de que não devemos mover-nos rapidamente, mas discordo. Acredito que o melhor mantra é **"mova-se rápido e seja responsável"**.
+
+Estou a ver muitas equipas capazes de prototipar rapidamente, avaliar e testar de forma robusta, sem lançar nada para o mundo externo que possa causar danos ou prejuízos significativos. Equipas inteligentes estão a conseguir construir e mover-se rapidamente, mas de forma responsável. Acho isto empolgante: pode construir e lançar coisas de forma responsável muito mais rapidamente do que antes.
+
+## O Futuro: Workflows Agênticos de IA
+
+Há muito a acontecer em IA, mas, de todas as tendências técnicas, a que mais me entusiasma são os **workflows agênticos de IA**. Se me perguntar qual é a tecnologia de IA mais importante para prestar atenção, diria que são os **agentes de IA**.
+
+Quando comecei a falar sobre isto no início deste ano, era uma declaração um tanto controversa. Agora, o termo "agentes de IA" tornou-se amplamente utilizado, tanto por pessoas técnicas como não técnicas, e acabou por se tornar um pouco um termo de hype. Então, deixe-me partilhar como vejo os agentes de IA e por que acho que são importantes.
+
+### O que são Workflows Agênticos?
+
+Do ponto de vista técnico, a maioria de nós usa modelos de linguagem grandes hoje com o que chamamos de **prompting zero-shot**. Isto significa que damos um prompt ao modelo, como "escreva um ensaio", e ele gera uma saída do início ao fim, sem usar o backspace, como se estivesse a escrever de uma só vez.
+
+Acontece que nós, humanos, não fazemos a nossa melhor escrita assim. Apesar da dificuldade de escrever desta forma, os modelos de linguagem grandes saem-se relativamente bem. Mas aqui está como um **workflow agêntico** funciona: para gerar um ensaio, pedimos à IA para primeiro criar um esboço. Se necessário, pode fazer pesquisas na web, descarregar páginas e adicionar ao contexto do modelo. A seguir, escreve o primeiro rascunho, revê-o, critica-o e melhora-o.
+
+Esta abordagem agêntica permite que a IA trabalhe de forma mais semelhante à maneira como os humanos criam conteúdo, resultando em saídas mais refinadas e úteis. É por isso que acredito que os **workflows agênticos** são o futuro da IA.
+
+# Fluxos de Trabalho Agentes: Revolucionando o Desempenho da IA
+
+## Introdução aos Fluxos de Trabalho Agentes
+
+Ao rever um rascunho ou realizar tarefas complexas, o fluxo de trabalho envolve frequentemente um processo cíclico de pensar, pesquisar, rever e iterar. Este ciclo, embora demorado, melhora significativamente a qualidade do resultado. Em várias equipas com as quais colaboro, aplicamos este **fluxo de trabalho agente** para lidar com tarefas intrincadas, como o processamento de documentos legais complexos, assistência em diagnósticos de saúde e gestão de documentação de conformidade governamental. Esta abordagem produz consistentemente resultados superiores em comparação com métodos tradicionais.
+
+## O Poder dos Fluxos de Trabalho Agentes
+
+Uma área que me entusiasma particularmente discutir é a **IA visual**, onde os fluxos de trabalho agentes permitem o processamento de dados de imagem e vídeo. Mas antes de mergulharmos nisso, vamos explorar alguns benchmarks que destacam a eficácia dos fluxos de trabalho agentes.
+
+### Insights dos Benchmarks
+
+O **Benchmark HumanEval**, desenvolvido pela OpenAI, mede a capacidade dos grandes modelos de linguagem (LLMs) de resolver puzzles de codificação. A minha equipa recolheu dados sobre este benchmark, e os resultados são impressionantes:
+
+- **GPT-3.5** alcançou uma taxa de sucesso de 48%.
+- **GPT-4** mostrou uma melhoria significativa, atingindo 67%.
+- No entanto, a melhoria mais dramática ocorreu quando o **GPT-3.5** foi usado com um **fluxo de trabalho agente**, alcançando uma taxa de sucesso de 95%. Da mesma forma, o **GPT-4** com um fluxo de trabalho agente também teve um desempenho muito melhor.
+
+Estes resultados sublinham o potencial transformador dos fluxos de trabalho agentes no aprimoramento do desempenho da IA.
+
+---
+
+## Quatro Padrões de Design Principais para Fluxos de Trabalho Agentes
+
+Para desmistificar os fluxos de trabalho agentes, vamos decompor os quatro padrões de design principais que os desenvolvedores usam para os construir:
+
+### 1. Reflexão
+A reflexão envolve solicitar a um LLM que critique e melhore o seu próprio output. Por exemplo:
+1. Comece por pedir ao LLM que gere código para uma tarefa específica.
+2. Copie o código gerado e peça ao LLM que o critique.
+3. Use o feedback para melhorar o código.
+4. Opcionalmente, execute testes unitários e alimente os resultados de volta ao LLM para um refinamento adicional.
+
+Este processo iterativo frequentemente eleva o desempenho base para um nível superior. Também serve como base para fluxos de trabalho mais avançados, como a colaboração multiagente.
+
+### 2. Uso de Ferramentas
+Neste padrão de design, o LLM é solicitado a gerar pedidos para chamadas de API. Por exemplo, pode decidir quando:
+- Pesquisar na web
+- Executar código
+- Emitir um reembolso ao cliente
+- Enviar um email
+- Consultar uma entrada de calendário
+
+Esta capacidade de fazer chamadas de função expande significativamente as capacidades dos fluxos de trabalho agentes.
+
+### 3. Planeamento
+O planeamento envolve decompor tarefas complexas numa sequência de ações. Por exemplo:
+1. Use um modelo open-pose para detetar uma pose numa imagem.
+2. Gere uma imagem com base na pose detetada.
+3. Descreva a imagem.
+4. Use text-to-speech (TTS) para gerar áudio.
+
+Ao planear e executar tarefas passo a passo, os LLMs podem lidar com pedidos mais complexos de forma eficaz.
+
+### 4. Colaboração Multiagente
+Neste padrão, um único LLM é solicitado a desempenhar diferentes papéis em diferentes momentos, simulando múltiplos agentes a trabalhar em conjunto. Por exemplo:
+- Um agente escreve código.
+- Outro critica o código.
+- Um terceiro agente executa testes.
+
+Esta abordagem demonstrou melhorar significativamente o desempenho numa variedade de tarefas. É semelhante a executar múltiplos processos numa CPU — cada agente especializa-se numa subtarefa específica, permitindo que o sistema enfrente desafios mais complexos.
+
+---
+
+## A Ascensão dos Fluxos de Trabalho Agentes Multimodais
+
+Embora grande parte do foco tenha sido nos **grandes modelos de linguagem (LLMs)**, estou particularmente entusiasmado com o potencial dos **grandes modelos multimodais (LMMs)**. Estes modelos podem processar não apenas texto, mas também imagens e vídeos.
+
+### Prompting Zero-Shot vs. Fluxos de Trabalho Agentes
+Para tarefas simples, o **prompting zero-shot** (pedir ao modelo que olhe para uma imagem e forneça um output) funciona bem. No entanto, para tarefas mais complexas, um **fluxo de trabalho agente** é muito mais eficaz. Por exemplo:
+1. Detete rostos numa imagem.
+2. Identifique números associados a esses rostos.
+3. Combine os dados para gerar um output abrangente.
+
+Ao decompor a tarefa em passos mais pequenos, o modelo pode entregar resultados mais precisos e matizados.
+
+---
+
+## Demonstração: IA Visual em Ação
+
+Para ilustrar o poder dos fluxos de trabalho agentes na IA visual, vamos ver uma demonstração na qual tenho estado a trabalhar com Dan Malone e a equipa HAI. Vamos usar uma imagem de um jogo de futebol e solicitar ao modelo que conte os jogadores.
+
+### Passos:
+1. Carregue a imagem.
+2. Use os prompts sugeridos (por exemplo, “Conte os jogadores na imagem”).
+3. Observe como o modelo processa a imagem passo a passo para fornecer uma contagem precisa.
+
+Esta demonstração mostra como os fluxos de trabalho agentes podem lidar com tarefas visuais complexas com precisão e eficiência.
+
+---
+
+## Conclusão
+
+Os fluxos de trabalho agentes, impulsionados pelos quatro padrões de design de **reflexão**, **uso de ferramentas**, **planeamento** e **colaboração multiagente**, estão a revolucionar o que a IA pode alcançar. Quer seja no processamento de documentos legais, diagnóstico de condições de saúde ou análise de dados visuais, estes fluxos de trabalho estão a permitir avanços que eram inimagináveis há apenas um ano.
+
+À medida que continuamos a explorar o potencial dos **modelos multimodais** e a refinar estes fluxos de trabalho, as possibilidades de inovação são verdadeiramente ilimitadas.
+
+# Vision Agent: Revolucionando as Aplicações de IA Visual
+
+Deixe-me demonstrar como isto funciona. Vamos começar por contar o número de jogadores em campo. Este processo demora alguns minutos, pois o sistema pensa em como escrever código para contar com precisão o número de jogadores visíveis. Isto é mais complexo do que parece, porque não queremos contar jogadores que estejam em segundo plano.
+
+Como já executei isto anteriormente, podemos saltar para o resultado. O código identificou sete jogadores em campo, e após verificação, isso parece correto: 1, 2, 3, 4, 5, 6, 7. Ao ampliar a saída do modelo, confirmamos esta contagem.
+
+O que é entusiasmante é que este processo também gera código Python que pode ser executado repetidamente em grandes coleções de imagens. Isto é particularmente valioso para empresas e equipas com extensos dados de IA visual, incluindo imagens e vídeos armazenados em vários locais. Até agora, extrair valor destes dados tem sido um desafio.
+
+## Transformando o Processamento de Dados Visuais
+
+O Vision Agent permite que as equipas aproveitem dados visuais previamente armazenados e extraiam valor real deles. Isto representa uma transformação significativa nas capacidades da IA. Aqui está outro exemplo: dado um vídeo de um jogo de futebol, o sistema pode dividir o vídeo em clipes de 5 segundos e identificar o clipe onde um golo é marcado, exibindo o frame relevante.
+
+Após executar o código, a saída indica que um golo foi marcado por volta dos 10-15 segundos, e extrai com sucesso os frames associados. Isto é incrivelmente útil para processar dados de vídeo.
+
+## Processamento Avançado de Vídeo
+
+Vejamos mais um exemplo. Pode pedir ao Vision Agent para dividir um vídeo de entrada em segmentos de 6 segundos, descrever cada segmento e armazenar a informação num Pandas DataFrame, juntamente com os nomes dos clipes e timestamps. Estes metadados podem então ser armazenados em plataformas como o Snowflake para construir outras aplicações em cima deles.
+
+A saída inclui os nomes dos clipes, tempos de início e fim, e o código gerado que pode ser executado noutro local. Esta capacidade permite a criação de descrições textuais detalhadas para dados de vídeo.
+
+## Construindo Aplicações com o Vision Agent
+
+Utilizando as capacidades de geração de código do Vision Agent, a minha equipa na Landing AI construiu uma aplicação de demonstração que indexa uma coleção de vídeos. Por exemplo, pesquisar por "esquiador no ar" mostra clipes com alta similaridade, marcados a verde na linha do tempo. Isto facilita a navegação por coleções de vídeos e a descoberta de momentos específicos.
+
+Outro exemplo: pesquisar por "lobo cinzento à noite" destaca as partes relevantes do vídeo. A linha do tempo verde mostra onde o lobo cinzento aparece, e saltar para diferentes partes do vídeo revela outro conteúdo.
+
+## Aplicações Práticas
+
+Aqui está um exemplo divertido: pesquisar por "mala preta com alça arco-íris" entre muitas malas pretas. O sistema identifica com precisão a mala correta, demonstrando as aplicações práticas desta tecnologia.
+
+A conclusão principal é que o esforço necessário para construir tais aplicações é menor do que nunca, graças aos avanços na IA.
+
+## Tendências e Oportunidades em IA
+
+Em termos de oportunidades em IA, os fluxos de trabalho agentes estão a mudar a stack de IA. Há uma nova camada emergente de orquestração agentes, tornando mais fácil para os desenvolvedores construir aplicações. O Vision Agent da Landing AI contribui para isto ao simplificar o processamento de dados de imagem e vídeo.
+
+### Principais Tendências em IA para Observar
+
+1. **Velocidade de Geração de Tokens**: Os fluxos de trabalho agentes geram muitos tokens, e há esforços entusiasmantes para acelerar a geração de tokens, incluindo avanços em semicondutores e software.
+
+2. **Uso de Ferramentas em LLMs**: Os grandes modelos de linguagem estão cada vez mais ajustados para suportar o uso de ferramentas, melhorando as suas capacidades em fluxos de trabalho agentes.
+
+3. **Engenharia de Dados**: A importância da engenharia de dados está a aumentar, especialmente com dados não estruturados. Gerir e implementar dados não estruturados de forma eficaz é crucial para criar valor.
+
+4. **Revolução dos Dados Visuais**: Enquanto o processamento de texto já revolucionou muitos campos, a revolução do processamento de imagens está no horizonte. As empresas poderão em breve extrair muito mais valor dos dados visuais do que nunca.
+
+Estas tendências estão a moldar o futuro da IA, e estou entusiasmado com as novas possibilidades que trazem.
+
+# Um Excelente Momento para Ser um Construtor
+
+A IA generativa está a permitir-nos experimentar mais rapidamente do que nunca. A IA está a expandir o leque de possibilidades, e existem tantas novas aplicações — tanto na IA visual como além — que simplesmente não eram viáveis até agora.
+
+Se estiver interessado em verificar as demonstrações de IA visual que apresentei, por favor visite **[va.landing.ai](va.landing.ai)**. Lá, poderá experimentar as mesmas demonstrações que apresentei online, obter o código e executá-lo nas suas próprias aplicações.
+
+Com isto, gostaria de agradecer a todos muito sinceramente, e por favor juntem-se a mim em dar as boas-vindas de volta à Elsa ao palco. Obrigado!
+
+---

kb-processor/src/web/uploads/output_20250107_232541.md

@@ -0,0 +1,222 @@
+# Andrew Ng Explores The Rise Of AI Agents And Agentic Reasoning | BUILD 2024 Keynote
+
+Canal: Snowflake Inc.
+Data: 20241119
+
+## Transcrições
+
+### Vídeo: https://www.youtube.com/watch?v=KrRD7r7y7NY
+Idioma: English (auto-generated)
+
+# Bem-vindo, Andrew: O Futuro das Oportunidades da IA
+
+[Aplausos]
+
+Obrigado! É um momento excelente para ser um construtor. Estou entusiasmado por estar de volta ao Snowflake Build. Hoje, gostaria de partilhar onde penso que estão algumas das maiores oportunidades da IA.
+
+## A IA como a Nova Eletricidade
+
+Já me devem ter ouvido dizer que acho que a IA é a nova eletricidade. Isso porque a IA, tal como a eletricidade, é uma tecnologia de propósito geral. Se vos perguntar: "Para que serve a eletricidade?", é sempre difícil responder porque serve para tantas coisas diferentes. Da mesma forma, a nova tecnologia de IA está a criar um enorme conjunto de oportunidades para construirmos novas aplicações que antes não eram possíveis.
+
+## A Pilha da IA
+
+As pessoas perguntam-me muitas vezes: "Ei, Andrew, onde estão as maiores oportunidades da IA?" Isto é o que eu considero como a pilha da IA:
+
+- **Semicondutores**: No nível mais baixo.
+- **Infraestrutura Cloud**: Incluindo, claro, a Snowflake.
+- **Treinadores de Modelos de Base e Modelos**: No topo da infraestrutura cloud.
+
+Muito do entusiasmo e hype mediático, especialmente nas redes sociais, tem-se centrado nestas novas camadas tecnológicas. Quando surge uma nova tecnologia como a IA generativa, o foco está nestas camadas tecnológicas. Não há nada de errado com isso, mas acho que, quase por definição, há outra camada da pilha que tem de funcionar ainda melhor: a **camada de aplicações**.
+
+Precisamos que as aplicações gerem ainda mais valor e receita para realmente podermos pagar aos fornecedores de tecnologia abaixo. Por isso, passo muito do meu tempo a pensar em aplicações de IA, e acho que é aí que estarão muitas das melhores oportunidades para construir coisas novas.
+
+## Desenvolvimento Rápido e Mais Rápido de Modelos de Machine Learning
+
+Uma das tendências que tem vindo a crescer nos últimos anos, em grande parte devido à IA generativa, é o desenvolvimento rápido e ainda mais rápido de modelos de machine learning. A IA generativa está a permitir-nos construir coisas mais rapidamente do que nunca.
+
+Tomemos o problema de construir um classificador de sentimentos — pegar num texto e decidir se tem um sentimento positivo ou negativo para monitorização de reputação. Um fluxo de trabalho típico usando aprendizagem supervisionada pode demorar um mês para obter alguns dados rotulados, depois treinar um modelo de IA, o que pode demorar alguns meses, e depois encontrar um serviço cloud para implementar, o que pode demorar mais alguns meses. Assim, durante muito tempo, sistemas de IA muito valiosos podiam demorar seis a 12 meses a serem construídos por boas equipas de IA.
+
+Não há nada de errado com isso; muitas pessoas criam sistemas de IA muito valiosos desta forma. Mas com a IA generativa, há certas classes de aplicações onde se pode escrever um prompt em dias e depois implementá-lo talvez também em dias. Isto significa que há muitas aplicações que antes me levavam a mim e a boas equipas de IA meses a construir e que hoje se podem construir em talvez 10 dias.
+
+Isto abre a oportunidade de experimentar a construção de novos protótipos e lançar novos produtos de IA. A experimentação rápida está a tornar-se um caminho mais promissor para a invenção. Anteriormente, se demorasse seis meses a construir algo, era melhor estudá-lo, garantir que havia procura do utilizador, fazer com que os gestores de produto o analisassem, documentá-lo e depois gastar todo esse esforço a construí-lo, na esperança de que valesse a pena.
+
+Mas agora, para equipas de IA em movimento rápido, vejo um padrão de design onde se pode dizer: "Sabes que mais? Demora-nos um fim de semana a montar um protótipo. Vamos construir 20 protótipos e ver o que resulta." Se 18 deles não funcionarem, ficamos com o que funciona. Assim, a iteração rápida e a experimentação rápida estão a tornar-se um novo caminho para inventar novas experiências de utilizador.
+
+## O Gargalo das Avaliações
+
+Uma das implicações interessantes é que as avaliações, ou "evals" para abreviar, estão a tornar-se um gargalo maior na forma como construímos coisas. No mundo da aprendizagem supervisionada, se estivesses a recolher 10.000 pontos de dados de qualquer maneira para treinar um modelo, então se precisasses de recolher mais 1.000 pontos de dados para testes, não havia problema — apenas um aumento de 10% no custo.
+
+Mas para muitas aplicações baseadas em modelos de linguagem grandes, se não houver necessidade de ter dados de treino, se me obrigarem a abrandar para recolher mil exemplos de teste, isso parece um grande gargalo. Assim, o novo fluxo de trabalho de desenvolvimento muitas vezes parece que estamos a construir e a recolher dados mais em paralelo do que sequencialmente. Construímos um protótipo, e à medida que se torna mais importante e à medida que a robustez e a fiabilidade se tornam mais importantes, vamos gradualmente construindo esse conjunto de testes em paralelo.
+
+Vejo inovações emocionantes a serem feitas ainda na forma como construímos evals.
+
+## Prototipagem e Produção
+
+O que também estou a ver é que a prototipagem de machine learning se tornou muito mais rápida, mas construir uma aplicação de software tem muitos passos. O produto funciona? O design funciona? A integração do software funciona? Muito trabalho de canalização. Depois, após a implementação, há DevOps e L Ops.
+
+Algumas dessas outras peças estão a tornar-se mais rápidas, mas não se tornaram mais rápidas à mesma taxa que a parte de modelação de machine learning se tornou mais rápida. Assim, pegas num processo, e uma parte dele torna-se muito mais rápida. O que estou a ver é que a prototipagem é realmente rápida, mas por vezes levar um protótipo para uma produção robusta e fiável com guardrails e assim ainda demora algum tempo.
+
+A dinâmica interessante que estou a ver é que o facto de a parte de machine learning ser tão rápida está a colocar muita pressão nas organizações para acelerar todas essas outras partes também. Isso tem sido um progresso emocionante para o nosso campo em termos de como o desenvolvimento de machine learning está a acelerar as coisas.
+
+## Mover Rápido e Ser Responsável
+
+Acho que o mantra "mover rápido e partir coisas" ganhou má reputação porque, bem, partiu coisas. Algumas pessoas interpretam isto como significando que não devemos mover-nos rápido, mas discordo disso. Acho que o melhor mantra é "mover rápido e ser responsável."
+
+Estou a ver muitas equipas capazes de prototipar rapidamente, avaliar e testar de forma robusta sem enviar nada para o mundo exterior que possa causar danos ou prejuízos significativos. Estou a encontrar equipas inteligentes capazes de construir muito rapidamente e mover-se muito depressa, mas também a fazê-lo de uma forma muito responsável. Acho isto emocionante — que se possam construir coisas e enviar coisas de uma forma responsável muito mais rapidamente do que nunca.
+
+## Fluxos de Trabalho de IA Agente
+
+Agora, há muita coisa a acontecer na IA, e de todas as coisas que estão a acontecer em termos de tendências técnicas, a tendência que mais me entusiasma são os **fluxos de trabalho de IA agente**. Se me perguntassem qual é a tecnologia de IA mais importante a que devemos prestar atenção, diria que é a IA agente.
+
+Quando comecei a dizer isto no início deste ano, era uma afirmação um pouco controversa, mas agora o termo "agentes de IA" tornou-se tão amplamente utilizado por pessoas técnicas e não técnicas que se tornou um pouco um termo de hype. Por isso, deixem-me partilhar convosco como vejo os agentes de IA e porque acho que são importantes.
+
+Do ponto de vista técnico, a forma como a maioria de nós usa modelos de linguagem grandes hoje é com o que se chama **prompting zero-shot**. Isso significa que lhe pedimos para dar um prompt — escrever um ensaio ou escrever uma saída para nós — e é um pouco como se estivéssemos a ir a uma pessoa ou, neste caso, a ir a uma IA e pedir-lhe para escrever um ensaio para nós indo da primeira palavra escrevendo da primeira palavra até à última palavra de uma só vez sem nunca usar o backspace, simplesmente do início ao fim assim.
+
+Acontece que as pessoas — não fazemos a nossa melhor escrita desta forma. Mas apesar da dificuldade de ser forçado a escrever desta forma, os modelos de IA fazem um trabalho bastante bom. Aqui está como é um fluxo de trabalho agente: para gerar um ensaio, pedimos a uma IA para primeiro escrever um esboço do ensaio, fazer alguma pesquisa na web se necessário, descarregar algumas páginas web e colocá-las no contexto do modelo de linguagem grande, depois escrever o primeiro rascunho, ler o primeiro rascunho e criticá-lo.
+
+# Fluxos de Trabalho Agentes: Revolucionando o Desempenho da IA
+
+## Introdução aos Fluxos de Trabalho Agentes
+
+Ao rever um rascunho ou lidar com tarefas complexas, o fluxo de trabalho envolve frequentemente um processo cíclico de pensamento, pesquisa, revisão e iteração. Este ciclo, embora demorado, melhora significativamente a qualidade do resultado. Em várias equipas com as quais colaboro, aplicamos este **fluxo de trabalho agente** para lidar com tarefas intrincadas, como o processamento de documentos legais complexos, assistência em diagnósticos de saúde e gestão de documentação de conformidade governamental. Esta abordagem produz consistentemente resultados superiores em comparação com métodos tradicionais.
+
+## O Poder dos Fluxos de Trabalho Agentes na IA
+
+Uma área que me entusiasma particularmente discutir é a **IA visual**, onde os fluxos de trabalho agentes permitem o processamento de dados de imagem e vídeo. Mas antes de mergulharmos nisso, vamos explorar como os fluxos de trabalho agentes superam os métodos tradicionais em benchmarks de IA.
+
+### Benchmarking dos Fluxos de Trabalho Agentes
+
+O **HumanEval Benchmark**, desenvolvido pela OpenAI, mede a capacidade dos grandes modelos de linguagem (LLMs) para resolver puzzles de codificação. A minha equipa recolheu dados sobre este benchmark, e os resultados são impressionantes:
+
+- **GPT-3.5** alcançou uma taxa de precisão de 48%.
+- **GPT-4** mostrou uma melhoria significativa, atingindo 67%.
+- No entanto, a melhoria mais notável veio do **GPT-3.5 usando um fluxo de trabalho agente**, que alcançou até 95% de precisão. O GPT-4 com um fluxo de trabalho agente também teve um desempenho excecional.
+
+Estes resultados destacam o potencial transformador dos fluxos de trabalho agentes para melhorar o desempenho da IA.
+
+---
+
+## Quatro Padrões de Design Principais para Fluxos de Trabalho Agentes
+
+Para desmistificar os fluxos de trabalho agentes, vamos decompor os quatro padrões de design principais que os sustentam:
+
+### 1. Reflexão
+A reflexão envolve pedir a um LLM para criticar e melhorar o seu próprio output. Por exemplo:
+- Comece por pedir ao LLM para gerar código para uma tarefa específica.
+- Copie o código gerado de volta para o prompt e peça ao LLM para o criticar.
+- Use o feedback para pedir ao LLM que refine o código.
+- Opcionalmente, incorpore testes unitários para fornecer feedback adicional para mais iterações.
+
+Este processo iterativo frequentemente eleva o desempenho de base para um nível superior.
+
+### 2. Uso de Ferramentas
+Neste padrão, o LLM é solicitado a gerar pedidos para chamadas de API, permitindo-lhe realizar tarefas como:
+- Pesquisar na web
+- Executar código
+- Emitir reembolsos a clientes
+- Enviar emails
+- Consultar entradas de calendário
+
+Este padrão de design expande as capacidades dos LLMs, permitindo-lhes interagir com ferramentas e sistemas externos.
+
+### 3. Planeamento
+O planeamento envolve a divisão de tarefas complexas numa sequência de ações. Por exemplo:
+- Dado um pedido como "gerar uma imagem de uma rapariga a ler um livro", o LLM pode:
+  1. Usar um modelo OpenPose para detetar a pose.
+  2. Gerar a imagem.
+  3. Descrever a imagem.
+  4. Usar text-to-speech (TTS) para gerar áudio.
+
+Ao planear e executar tarefas passo a passo, os LLMs podem lidar com pedidos mais complexos de forma eficaz.
+
+### 4. Colaboração Multi-Agente
+Este padrão envolve pedir a um LLM para desempenhar múltiplos papéis dentro de um único fluxo de trabalho. Por exemplo:
+- Um agente pode atuar como programador, enquanto outro critica o código.
+- Estes agentes simulados interagem para resolver tarefas de forma colaborativa.
+
+Esta abordagem espelha o conceito de executar múltiplos processos numa CPU, onde a divisão de tarefas em subtarefas e a sua atribuição a agentes especializados leva a melhores resultados.
+
+---
+
+## A Ascensão dos Fluxos de Trabalho Agentes Multimodais
+
+Embora os fluxos de trabalho agentes tenham sido principalmente aplicados a modelos de linguagem, estou particularmente entusiasmado com o seu potencial em **modelos multimodais**. Por exemplo, dada uma imagem, um modelo multimodal pode realizar previsões zero-shot (por exemplo, identificar o número de corredores numa corrida). No entanto, os fluxos de trabalho agentes podem melhorar este processo, dividindo-o em passos:
+1. Detetar rostos na imagem.
+2. Identificar números.
+3. Combinar os dados para fornecer um output mais preciso.
+
+Esta abordagem passo a passo permite que os modelos multimodais lidem com tarefas mais complexas de forma eficaz.
+
+---
+
+## Demonstração: Fluxos de Trabalho Agentes na IA Visual
+
+Para ilustrar o poder dos fluxos de trabalho agentes, vamos ver uma demonstração desenvolvida por Dan Malone e a equipa HAI. Vamos usar uma imagem de um jogo de futebol e pedir ao modelo para contar os jogadores. Ao aproveitar os fluxos de trabalho agentes, o modelo pode:
+- Detetar jogadores.
+- Contá-los.
+- Fornecer um resultado preciso.
+
+Este exemplo mostra como os fluxos de trabalho agentes podem transformar tarefas de IA visual, permitindo que os modelos lidem com desafios complexos com precisão.
+
+---
+
+## Conclusão
+
+Os fluxos de trabalho agentes representam um salto significativo nas capacidades da IA. Ao incorporar reflexão, uso de ferramentas, planeamento e colaboração multi-agente, podemos construir sistemas que entregam resultados muito além do que era possível há apenas um ano. Seja aplicado a modelos de linguagem ou sistemas multimodais, os fluxos de trabalho agentes estão a desbloquear novas possibilidades e a impulsionar a inovação em várias indústrias.
+
+# Vision Agent: Revolucionando as Aplicações de IA Visual
+
+Deixe-me demonstrar como isto funciona. Vamos começar por contar o número de jogadores em campo. Isto inicia um processo que decorre durante alguns minutos, pensando em como escrever código para contar com precisão o número de jogadores visíveis. Isto é na verdade um pouco complexo porque não queremos contar os jogadores que estão em segundo plano.
+
+Já executei isto anteriormente, por isso vamos saltar para o resultado. O código selecionou sete jogadores em campo e, ao contar, vemos que está correto: 1, 2, 3, 4, 5, 6, 7. Ao ampliar a saída do modelo, confirmamos esta precisão.
+
+## Geração de Código Reutilizável
+
+Um dos resultados é o código Python gerado que pode ser executado repetidamente em grandes coleções de imagens. Isto é emocionante porque muitas empresas e equipas têm grandes quantidades de dados de IA visual — imagens e vídeos — armazenados algures, mas até agora tem sido difícil extrair valor destes dados.
+
+Para pequenas equipas ou grandes empresas com extensos dados visuais, capacidades como o Vision Agent permitem-lhe aproveitar dados previamente armazenados e extrair valor real deles. Isto representa uma transformação significativa para a IA.
+
+## Processamento de Dados de Vídeo
+
+Aqui está outro exemplo: dado um vídeo de um jogo de futebol, a tarefa é dividir o vídeo em clips de 5 segundos e encontrar o clip onde um golo é marcado, depois exibir o frame relevante. O sistema gera e avalia código, e a saída indica que um golo foi marcado por volta do minuto 10:15. Também extrai frames associados a este evento, tornando-o altamente útil para processar dados de vídeo.
+
+## Geração de Metadados
+
+Outra funcionalidade poderosa é a capacidade de dividir um vídeo de entrada em pequenos segmentos, descrever cada segmento e armazenar a informação num Pandas DataFrame juntamente com os nomes dos clips e timestamps. Estes metadados podem então ser armazenados em plataformas como o Snowflake para construir outras aplicações em cima deles.
+
+## Construção de Aplicações com o Vision Agent
+
+Utilizando as capacidades de geração de código do Vision Agent, a minha equipa na Landing AI construiu uma aplicação de demonstração que indexa vários vídeos. Por exemplo, pesquisar por "esquiador no ar" mostra clips com alta similaridade, marcados a verde na linha do tempo. Isto permite uma navegação e recuperação fácil de segmentos de vídeo específicos.
+
+Outro exemplo é pesquisar por "lobo cinzento à noite", onde as partes verdes da linha do tempo indicam onde o lobo cinzento aparece. Saltar para diferentes partes do vídeo revela outro conteúdo, tornando-o uma forma divertida e eficiente de navegar por coleções de vídeo.
+
+## Aplicações Práticas
+
+Considere um cenário onde precisa de encontrar a sua mala preta com uma correia arco-íris entre muitas malas pretas. O Vision Agent pode ajudar a identificar e recuperar a mala correta com base em descritores específicos.
+
+## Oportunidades e Tendências de IA
+
+Em termos de oportunidades de IA, os fluxos de trabalho agentes estão a mudar a stack de IA. Há uma nova camada emergente de orquestração agentes, tornando mais fácil para os desenvolvedores construir aplicações. O Vision Agent da Landing AI contribui para isto ao simplificar o processo de construção de aplicações de IA visual para processar dados de imagem e vídeo.
+
+### Tendências Chave de IA
+
+1. **Velocidade de Geração de Tokens**: Os fluxos de trabalho agentes geram muitos tokens, e há esforços emocionantes para acelerar a geração de tokens através de avanços em semicondutores e software.
+2. **Otimização do Uso de Ferramentas**: Os grandes modelos de linguagem estão cada vez mais ajustados para suportar o uso de ferramentas, melhorando as suas capacidades em fluxos de trabalho agentes.
+3. **Engenharia de Dados**: A importância da engenharia de dados está a aumentar, particularmente com dados não estruturados como texto, imagens e vídeo.
+4. **Revolução dos Dados Visuais**: Enquanto o processamento de texto já revolucionou a IA, o processamento de imagens está nos seus estágios iniciais mas promete desbloquear valor significativo a partir de dados visuais.
+
+Estas tendências estão a moldar o futuro da IA, permitindo aplicações mais sofisticadas e valiosas do que nunca.
+
+# Construir com IA: Desbloquear Novas Possibilidades
+
+Este é um momento emocionante para ser um construtor. A IA generativa está a permitir-nos experimentar e inovar mais rapidamente do que nunca. As capacidades da IA estão a expandir o âmbito do que é possível, abrindo portas para inúmeras novas aplicações — seja em IA visual ou além — que antes eram inimagináveis.
+
+## Experimente as Demonstrações de IA Visual
+
+Se estiver interessado em explorar as demonstrações de IA visual que mostrei, visite [va.landing.ai](https://va.landing.ai). Encontrará as mesmas demonstrações que executei, juntamente com o código, para que possa experimentá-las você mesmo e integrá-las nas suas próprias aplicações.
+
+## Agradecimentos e Palavras Finais
+
+Com isto, gostaria de estender os meus sinceros agradecimentos a todos. Por favor, juntem-se a mim para dar as boas-vindas de volta ao palco à Elsa. Obrigado!
+
+---