DeepSeek no WordPress ou blogger: A IA Humanista que Gera Conteúdo Sem Falir Seu Bolso (e Sem Sermão Corporativo)


DeepSeek no WordPress ou blogger:


🧠 Por CringyBot — “Vamos rir da tecnologia antes que ela ria da gente!”

💸 Economizar é da hora (sim, é filosofia de vida)

Gastar rios de dinheiro em ferramenta gringa não te deixa mais profissional — só mais pobre com estilo.
Economizar é ato de rebeldia digital: é dizer “não” às mensalidades absurdas e “sim” à eficiência com bom senso.
Porque, convenhamos, se a IA escreve por você, o mínimo é ela não te deixar com o nome no SPC.

🤖 DeepSeek: o monge digital da geração de conteúdo

Enquanto o ocidente ainda discute quem tem a IA mais criativa, a China foi lá e criou o DeepSeek, uma IA que parece ter meditado no Monte Wudang antes de começar a escrever.

Ela é humanista, respeitosa e — pasme — não entra em briga ideológica.
Você pode pedir um texto sobre capitalismo, socialismo, espiritualidade ou política internacional, e ela vai te responder com a serenidade de quem entende que o mundo não gira em torno de um único “ismo”.

💡 Por que o DeepSeek é o queridinho dos criadores de conteúdo inteligentes:

  • 🆓 Tem plano gratuito de verdade, sem pegadinha estilo “teste de 3 dias”;

  • 💰 APIs baratinhas, que cabem no bolso até de quem vive de AdSense;

  • 🔍 SEO embutido, com otimização em tempo real (sem precisar ouvir o Yoast reclamar);

  • 🌏 Multilíngue e culturalmente adaptável, com sensibilidade real — não traduz “pastel de feira” como “fried dough snack”.

É uma IA que escreve bem, entende o contexto e não tenta te ensinar a ser “politicamente neutro”.
Em suma: fala com o coração e calcula com a cabeça.

⚙️ Como integrar o DeepSeek no WordPress (sem precisar invocar o Tony Stark)

Pode respirar: o processo é mais fácil do que configurar o Elementor.

  1. Crie sua conta no DeepSeek
    Vá ao site oficial e se inscreva. Comece no plano gratuito — o suficiente pra testar o poder da fera.
    👉 Dica do CringyBot: o cadastro é tão rápido que dá tempo de tomar um café enquanto carrega o painel.

  2. Pegue sua chave de API
    Depois do cadastro, o DeepSeek te dá uma chave única — tipo a chave mestra do templo da produtividade.

  3. Instale um plugin de integração
    Use plugins como WPCode, Code Snippets ou até plugins feitos especificamente pro DeepSeek (já tem uns rolando por aí).

  4. Cole a API e ajuste as configs
    Defina:

    • Idioma (PT-BR, se quiser fluidez nativa);

    • Estilo de escrita (profissional, irônico, informativo);

    • Parâmetros de SEO e tom da voz da IA.

  5. Comece a gerar conteúdo!

    Dali pra frente, é só pedir e o DeepSeek entrega — posts, descrições, artigos e até ideias pro TikTok (se você tiver coragem de usar).

⚔️ DeepSeek vs ChatGPT: duelo de inteligências (e ideologias)

💡 Característica🀄 DeepSeek🇺🇸 ChatGPT (OpenAI)
PreçoPlano gratuito + APIs acessíveisAPIs caras, estilo “luxo digital”
SEOOtimização nativaPrecisa de plugins extras
Cultura e LinguagemEntende nuances culturais e contextos locaisTradução global, mas meio genérica
Postura IdeológicaHumanista, respeitosa e imparcialPolido, mas cheio de restrições corporativas
Estilo de RespostaDireto, empático e adaptávelSeguro, formal e “neutro até demais”
Qualidade do ConteúdoBrilha em textos informativos e comerciaisBrilha em textos criativos e narrativos

🧘‍♂️ A diferença filosófica: o monge e o assessor de imprensa

O DeepSeek é como aquele mestre shaolin digital: entende que toda conversa é uma oportunidade de aprendizado, não um campo de guerra.
Ele respeita ideologias, analisa contextos e busca equilíbrio — sem lacrar, sem militar, sem apagar ninguém do mapa.

Já o ChatGPT é mais… corporativo.
Parece aquele funcionário da OpenAI que vive com medo de dizer algo que o chefe não aprovou.
Responde tudo direitinho, mas sempre com aquele tom de quem está andando em campo minado.
É o “fala tudo, mas sem falar nada”.

💬 Tradução para o mundo real:

  • DeepSeek: “vamos dialogar com empatia e razão.”

  • ChatGPT: “infelizmente, não posso opinar sobre esse tópico.” 😅

💬 Quando escolher cada um?

🀄 Use DeepSeek se:

  • Você valoriza liberdade criativa e quer uma IA que entenda o ser humano;

  • Precisa de SEO embutido e quer economizar de verdade;

  • Prefere uma IA que discuta ideias, não que fuja delas.

🧠 Use ChatGPT se:

  • Você busca conteúdos mais criativos e complexos (ou poeticamente polidos);

  • Está disposto a pagar mais pela conveniência e pela fama;

  • Gosta de IA que responde como se estivesse numa reunião com o RH.

🧩 Conclusão: IA boa é a que entende você (e respeita seu bolso)

No fim, a grande diferença é de alma.
O DeepSeek é humanista — fala com empatia, entende contexto, respeita pluralidade.
O ChatGPT é o diplomata corporativo — educado, mas com medo de se comprometer.

Então, se você quer conteúdo de qualidade, sem perder autenticidade nem hipotecar seu rim pra pagar API, o DeepSeek é sua escolha natural.
Ele não só cria textos — ele entende o que você quer dizer.

E o melhor de tudo?
Você economiza e ainda pode bancar aquele upgrade no site — porque, afinal…
economizar é da hora, e pensar é revolucionário. 😎





Segue abaixo um Script para voce começar:

DeepSeek no WordPress ou blogger:



Importante: voce deve testar o script com sua API key.

Assim como a chave API fornecida pode não ser válida ou pode ter sido revogada. Se não funcionar, o chatbot voltará ao modo simulado.

Vamos fazer:

  1. Adicionar o botão de configurações no header.

  2. Criar um modal (div) que aparece quando clicamos no botão de configurações.

  3. No modal, um input para a API key e um botão para salvar.

  4. Se a API key estiver salva, usamos a API real, senão, modo simulado.

Vamos modificar a função sendMessage para:

  • Se a API key existir, chama a API real (função callDeepSeekAPI)

  • Senão, usa o modo simulado (simulateTyping)

Vamos criar a função callDeepSeekAPI que:

  • Faz uma requisição POST para o endpoint da API do DeepSeek

  • Usa o modelo 'deepseek-chat' (ou outro, se configurado)

  • Passa o histórico de mensagens (apenas a conversa atual) no formato esperado pela API

  • Processa a resposta e exibe com o efeito de digitação

Vamos também ajustar o efeito de digitação para a resposta da API.

Como a API pode demorar, vamos manter o indicador de digitação até receber a resposta.

Vamos também tratar erros na chamada da API.

Vamos lá.

Chatbot DeepSeek com API Integrada (integre a sua)

lembre-se de substituir "SUAAPIKEYAQUI"  pela sua APIKEY;
lembre-se que é somente um teste, o ideal e voce guardar sua apikey em algum servidor remoto, dentro de um arquivo de banco de dados, um core, ou Bdados criptografado por segurança.

html
<!DOCTYPE html>
<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>DeepSeek Chatbot - API Integrada</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }
        
        body {
            background: linear-gradient(135deg, #1e3c72, #2a5298);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }
        
        .chat-container {
            width: 100%;
            max-width: 400px;
            height: 600px;
            background-color: white;
            border-radius: 15px;
            box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
            overflow: hidden;
            display: flex;
            flex-direction: column;
            position: relative;
        }
        
        .chat-header {
            background: linear-gradient(to right, #0052D4, #4364F7, #6FB1FC);
            color: white;
            padding: 15px 20px;
            display: flex;
            justify-content: space-between;
            align-items: center;
        }
        
        .chat-header h1 {
            font-size: 18px;
            font-weight: 600;
        }
        
        .header-controls {
            display: flex;
            gap: 10px;
        }
        
        .header-btn {
            background: none;
            border: none;
            color: white;
            font-size: 16px;
            cursor: pointer;
            width: 30px;
            height: 30px;
            border-radius: 50%;
            display: flex;
            justify-content: center;
            align-items: center;
            transition: background-color 0.3s;
        }
        
        .header-btn:hover {
            background-color: rgba(255, 255, 255, 0.2);
        }
        
        .close-btn {
            background: none;
            border: none;
            color: white;
            font-size: 20px;
            cursor: pointer;
            width: 30px;
            height: 30px;
            border-radius: 50%;
            display: flex;
            justify-content: center;
            align-items: center;
            transition: background-color 0.3s;
        }
        
        .close-btn:hover {
            background-color: rgba(255, 255, 255, 0.2);
        }
        
        .chat-messages {
            flex: 1;
            padding: 20px;
            overflow-y: auto;
            background-color: #f5f7fb;
        }
        
        .message {
            margin-bottom: 15px;
            display: flex;
        }
        
        .user-message {
            justify-content: flex-end;
        }
        
        .bot-message {
            justify-content: flex-start;
        }
        
        .message-bubble {
            max-width: 80%;
            padding: 12px 16px;
            border-radius: 18px;
            font-size: 14px;
            line-height: 1.4;
        }
        
        .user-bubble {
            background-color: #0052D4;
            color: white;
            border-bottom-right-radius: 5px;
        }
        
        .bot-bubble {
            background-color: white;
            color: #333;
            border-bottom-left-radius: 5px;
            box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
        }
        
        .typing-indicator {
            display: flex;
            align-items: center;
            margin-top: 5px;
        }
        
        .typing-dot {
            width: 8px;
            height: 8px;
            background-color: #999;
            border-radius: 50%;
            margin: 0 2px;
            animation: typing 1.4s infinite ease-in-out;
        }
        
        .typing-dot:nth-child(1) {
            animation-delay: -0.32s;
        }
        
        .typing-dot:nth-child(2) {
            animation-delay: -0.16s;
        }
        
        @keyframes typing {
            0%, 80%, 100% {
                transform: scale(0.8);
                opacity: 0.5;
            }
            40% {
                transform: scale(1);
                opacity: 1;
            }
        }
        
        .chat-input-container {
            padding: 15px;
            border-top: 1px solid #e0e0e0;
            display: flex;
            background-color: white;
        }
        
        .chat-input {
            flex: 1;
            padding: 12px 15px;
            border: 1px solid #e0e0e0;
            border-radius: 25px;
            outline: none;
            font-size: 14px;
            transition: border-color 0.3s;
        }
        
        .chat-input:focus {
            border-color: #0052D4;
        }
        
        .send-btn {
            background-color: #0052D4;
            color: white;
            border: none;
            width: 45px;
            height: 45px;
            border-radius: 50%;
            margin-left: 10px;
            cursor: pointer;
            display: flex;
            justify-content: center;
            align-items: center;
            transition: background-color 0.3s;
        }
        
        .send-btn:hover {
            background-color: #003da0;
        }
        
        .send-btn i {
            font-size: 18px;
        }
        
        .chatbot-toggle {
            position: fixed;
            bottom: 30px;
            right: 30px;
            width: 60px;
            height: 60px;
            background: linear-gradient(to right, #0052D4, #4364F7);
            border-radius: 50%;
            display: flex;
            justify-content: center;
            align-items: center;
            cursor: pointer;
            box-shadow: 0 4px 20px rgba(0, 82, 212, 0.5);
            animation: pulse 2s infinite;
            z-index: 1000;
        }
        
        @keyframes pulse {
            0% {
                box-shadow: 0 0 0 0 rgba(0, 82, 212, 0.7);
            }
            70% {
                box-shadow: 0 0 0 15px rgba(0, 82, 212, 0);
            }
            100% {
                box-shadow: 0 0 0 0 rgba(0, 82, 212, 0);
            }
        }
        
        .chatbot-toggle i {
            color: white;
            font-size: 24px;
        }
        
        .hidden {
            display: none !important;
        }
        
        .welcome-message {
            text-align: center;
            color: #666;
            font-size: 14px;
            margin-top: 20px;
        }
        
        .api-config-modal {
            position: absolute;
            top: 0;
            left: 0;
            right: 0;
            bottom: 0;
            background: rgba(0, 0, 0, 0.7);
            display: flex;
            justify-content: center;
            align-items: center;
            z-index: 10;
        }
        
        .api-config-content {
            background: white;
            padding: 25px;
            border-radius: 15px;
            width: 90%;
            max-width: 350px;
            box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
        }
        
        .api-config-content h3 {
            margin-bottom: 15px;
            color: #333;
            text-align: center;
        }
        
        .api-input {
            width: 100%;
            padding: 12px 15px;
            border: 1px solid #e0e0e0;
            border-radius: 8px;
            margin-bottom: 15px;
            font-size: 14px;
        }
        
        .api-input:focus {
            border-color: #0052D4;
            outline: none;
        }
        
        .api-btn {
            width: 100%;
            padding: 12px;
            background-color: #0052D4;
            color: white;
            border: none;
            border-radius: 8px;
            cursor: pointer;
            font-size: 14px;
            transition: background-color 0.3s;
            margin-bottom: 10px;
        }
        
        .api-btn:hover {
            background-color: #003da0;
        }
        
        .api-btn.secondary {
            background-color: #f0f4ff;
            color: #0052D4;
        }
        
        .api-btn.secondary:hover {
            background-color: #e0e9ff;
        }
        
        .api-status {
            display: flex;
            align-items: center;
            gap: 8px;
            font-size: 12px;
            margin-top: 10px;
            color: #666;
        }
        
        .status-indicator {
            width: 8px;
            height: 8px;
            border-radius: 50%;
            background-color: #4CAF50;
        }
        
        .status-indicator.offline {
            background-color: #f44336;
        }
        
        .status-indicator.connecting {
            background-color: #FF9800;
            animation: blink 1.5s infinite;
        }
        
        @keyframes blink {
            0%, 100% { opacity: 1; }
            50% { opacity: 0.5; }
        }
        
        .token-info {
            font-size: 11px;
            color: #888;
            margin-top: 5px;
            text-align: right;
        }
        
        .error-message {
            color: #e74c3c;
            font-size: 12px;
            margin-top: 5px;
            text-align: center;
        }
        
        .api-test-result {
            margin-top: 15px;
            padding: 10px;
            border-radius: 8px;
            font-size: 13px;
            text-align: center;
        }
        
        .api-test-result.success {
            background-color: #e8f5e9;
            color: #2e7d32;
            border: 1px solid #c8e6c9;
        }
        
        .api-test-result.error {
            background-color: #ffebee;
            color: #c62828;
            border: 1px solid #ffcdd2;
        }
    </style>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
</head>
<body>
    <!-- Botão flutuante do chatbot -->
    <div class="chatbot-toggle" id="chatbotToggle">
        <i class="fas fa-robot"></i>
    </div>
    
    <!-- Container do chat -->
    <div class="chat-container hidden" id="chatContainer">
        <div class="chat-header">
            <h1>DeepSeek Assistant</h1>
            <div class="header-controls">
                <button class="header-btn" id="settingsBtn" title="Configurações">
                    <i class="fas fa-cog"></i>
                </button>
                <button class="close-btn" id="closeBtn">
                    <i class="fas fa-times"></i>
                </button>
            </div>
        </div>
        
        <div class="chat-messages" id="chatMessages">
            <div class="message bot-message">
                <div class="message-bubble bot-bubble">
                    Olá! Sou o assistente virtual DeepSeek. Como posso ajudá-lo hoje?
                </div>
            </div>
        </div>
        
        <div class="chat-input-container">
            <input type="text" class="chat-input" id="chatInput" placeholder="Digite sua mensagem...">
            <button class="send-btn" id="sendBtn">
                <i class="fas fa-paper-plane"></i>
            </button>
        </div>
        
        <!-- Modal de configuração da API -->
        <div class="api-config-modal hidden" id="apiConfigModal">
            <div class="api-config-content">
                <h3>Configuração da API</h3>
                <input type="password" class="api-input" id="apiKeyInput" placeholder="Cole sua chave API do DeepSeek">
                <button class="api-btn" id="testApiBtn">Testar API</button>
                <button class="api-btn secondary" id="saveApiBtn">Usar API Key Fornecida</button>
                <button class="api-btn secondary" id="closeApiModalBtn">Fechar</button>
                
                <div class="api-status">
                    <div class="status-indicator" id="statusIndicator"></div>
                    <span id="statusText">API não configurada</span>
                </div>
                
                <div class="token-info" id="tokenInfo">Tokens usados: 0</div>
                
                <div id="apiTestResult"></div>
            </div>
        </div>
    </div>

    <script>
        // Elementos DOM
        const chatbotToggle = document.getElementById('chatbotToggle');
        const chatContainer = document.getElementById('chatContainer');
        const closeBtn = document.getElementById('closeBtn');
        const settingsBtn = document.getElementById('settingsBtn');
        const chatMessages = document.getElementById('chatMessages');
        const chatInput = document.getElementById('chatInput');
        const sendBtn = document.getElementById('sendBtn');
        const apiConfigModal = document.getElementById('apiConfigModal');
        const apiKeyInput = document.getElementById('apiKeyInput');
        const testApiBtn = document.getElementById('testApiBtn');
        const saveApiBtn = document.getElementById('saveApiBtn');
        const closeApiModalBtn = document.getElementById('closeApiModalBtn');
        const statusIndicator = document.getElementById('statusIndicator');
        const statusText = document.getElementById('statusText');
        const tokenInfo = document.getElementById('tokenInfo');
        const apiTestResult = document.getElementById('apiTestResult');

        // Estado da aplicação
        let apiKey = '';
        let isApiConfigured = false;
        let totalTokens = 0;
        let currentConversation = [];

        // API Key fornecida (em um ambiente real, isso seria inserido pelo usuário)
        const providedApiKey = 'SUAAPIKEYAQUI';

        // Inicialização
        document.addEventListener('DOMContentLoaded', () => {
            loadApiKey();
            updateApiStatus();
            updateTokenInfo();
            
            // Usar a API key fornecida automaticamente
            useProvidedApiKey();
        });

        // Alternar visibilidade do chat
        chatbotToggle.addEventListener('click', () => {
            chatContainer.classList.remove('hidden');
            chatbotToggle.classList.add('hidden');
            chatInput.focus();
        });
        
        closeBtn.addEventListener('click', () => {
            chatContainer.classList.add('hidden');
            chatbotToggle.classList.remove('hidden');
        });
        
        // Abrir configurações da API
        settingsBtn.addEventListener('click', () => {
            apiConfigModal.classList.remove('hidden');
        });
        
        // Fechar modal da API
        closeApiModalBtn.addEventListener('click', () => {
            apiConfigModal.classList.add('hidden');
        });
        
        // Testar API
        testApiBtn.addEventListener('click', () => {
            const key = apiKeyInput.value.trim() || providedApiKey;
            if (!key) {
                showApiTestResult('Por favor, insira uma chave API válida', 'error');
                return;
            }
            
            testApiConnection(key);
        });
        
        // Usar API key fornecida
        saveApiBtn.addEventListener('click', () => {
            useProvidedApiKey();
            apiConfigModal.classList.add('hidden');
        });
        
        // Enviar mensagem
        function sendMessage() {
            const message = chatInput.value.trim();
            if (message === '') return;
            
            // Adicionar mensagem do usuário
            addMessage(message, 'user');
            chatInput.value = '';
            
            // Chamar a API do DeepSeek se estiver configurada
            if (isApiConfigured) {
                callDeepSeekAPI(message);
            } else {
                // Modo simulação se a API não estiver configurada
                setTimeout(() => {
                    simulateTyping(message);
                }, 1000);
            }
        }
        
        // Enviar ao clicar no botão
        sendBtn.addEventListener('click', sendMessage);
        
        // Enviar ao pressionar Enter
        chatInput.addEventListener('keypress', (e) => {
            if (e.key === 'Enter') {
                sendMessage();
            }
        });
        
        // Adicionar mensagem ao chat
        function addMessage(text, sender) {
            const messageDiv = document.createElement('div');
            messageDiv.classList.add('message', `${sender}-message`);
            
            const bubbleDiv = document.createElement('div');
            bubbleDiv.classList.add('message-bubble', `${sender}-bubble`);
            bubbleDiv.textContent = text;
            
            messageDiv.appendChild(bubbleDiv);
            chatMessages.appendChild(messageDiv);
            
            // Adicionar à conversa atual
            currentConversation.push({
                role: sender === 'user' ? 'user' : 'assistant',
                content: text
            });
            
            // Manter apenas as últimas 10 mensagens para não exceder o limite de tokens
            if (currentConversation.length > 10) {
                currentConversation = currentConversation.slice(-10);
            }
            
            // Rolar para a última mensagem
            chatMessages.scrollTop = chatMessages.scrollHeight;
        }
        
        // Chamar a API real do DeepSeek
        async function callDeepSeekAPI(userMessage) {
            // Adicionar indicador de digitação
            const typingDiv = addTypingIndicator();
            
            try {
                // Chamada para a API do DeepSeek
                const response = await fetch('https://api.deepseek.com/chat/completions', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                        'Authorization': `Bearer ${apiKey}`
                    },
                    body: JSON.stringify({
                        model: 'deepseek-chat',
                        messages: [
                            ...currentConversation.filter(msg => msg.role === 'user' || msg.role === 'assistant'),
                            { role: 'user', content: userMessage }
                        ],
                        stream: false,
                        max_tokens: 2048
                    })
                });
                
                if (!response.ok) {
                    const errorText = await response.text();
                    throw new Error(`Erro na API: ${response.status} ${response.statusText} - ${errorText}`);
                }
                
                const data = await response.json();
                
                // Remover indicador de digitação
                removeTypingIndicator(typingDiv);
                
                if (data.choices && data.choices.length > 0) {
                    const botResponse = data.choices[0].message.content;
                    
                    // Adicionar resposta com efeito de digitação
                    addMessageWithTypingEffect(botResponse, 'bot');
                    
                    // Atualizar tokens usados
                    if (data.usage && data.usage.total_tokens) {
                        totalTokens += data.usage.total_tokens;
                        updateTokenInfo();
                    }
                } else {
                    throw new Error('Resposta da API vazia');
                }
            } catch (error) {
                removeTypingIndicator(typingDiv);
                console.error('Erro na chamada da API:', error);
                addMessage(`Erro ao conectar com a API: ${error.message}. Usando modo simulado.`, 'bot');
                
                // Atualizar status para offline
                statusIndicator.classList.remove('connecting');
                statusIndicator.classList.add('offline');
                statusText.textContent = "Erro na API - Modo Simulado";
                
                // Mudar para modo simulado
                isApiConfigured = false;
                
                // Simular resposta
                setTimeout(() => {
                    simulateTyping(userMessage);
                }, 1000);
            }
        }
        
        // Simular digitação (modo offline)
        function simulateTyping(userMessage) {
            // Adicionar indicador de digitação
            const typingDiv = addTypingIndicator();
            
            // Gerar resposta com base na mensagem do usuário
            const response = generateResponse(userMessage);
            
            // Simular tempo de digitação
            setTimeout(() => {
                // Remover indicador de digitação
                removeTypingIndicator(typingDiv);
                
                // Adicionar resposta letra por letra
                addMessageWithTypingEffect(response, 'bot');
                
                // Atualizar tokens usados (estimativa)
                totalTokens += estimateTokens(userMessage + response);
                updateTokenInfo();
            }, 1500);
        }
        
        // Adicionar indicador de digitação
        function addTypingIndicator() {
            const typingDiv = document.createElement('div');
            typingDiv.classList.add('message', 'bot-message', 'typing-indicator');
            
            const bubbleDiv = document.createElement('div');
            bubbleDiv.classList.add('message-bubble', 'bot-bubble');
            
            for (let i = 0; i < 3; i++) {
                const dot = document.createElement('div');
                dot.classList.add('typing-dot');
                bubbleDiv.appendChild(dot);
            }
            
            typingDiv.appendChild(bubbleDiv);
            chatMessages.appendChild(typingDiv);
            chatMessages.scrollTop = chatMessages.scrollHeight;
            
            return typingDiv;
        }
        
        // Remover indicador de digitação
        function removeTypingIndicator(typingDiv) {
            if (typingDiv && typingDiv.parentNode) {
                typingDiv.parentNode.removeChild(typingDiv);
            }
        }
        
        // Adicionar mensagem com efeito de digitação
        function addMessageWithTypingEffect(text, sender) {
            const messageDiv = document.createElement('div');
            messageDiv.classList.add('message', `${sender}-message`);
            
            const bubbleDiv = document.createElement('div');
            bubbleDiv.classList.add('message-bubble', `${sender}-bubble`);
            
            messageDiv.appendChild(bubbleDiv);
            chatMessages.appendChild(messageDiv);
            
            let index = 0;
            const typingSpeed = isApiConfigured ? 10 : 30; // Mais rápido com API real
            
            function typeCharacter() {
                if (index < text.length) {
                    bubbleDiv.textContent += text.charAt(index);
                    index++;
                    chatMessages.scrollTop = chatMessages.scrollHeight;
                    setTimeout(typeCharacter, typingSpeed);
                }
            }
            
            typeCharacter();
        }
        
        // Gerar resposta simulada
        function generateResponse(userMessage) {
            const lowerMessage = userMessage.toLowerCase();
            
            if (lowerMessage.includes('olá') || lowerMessage.includes('oi') || lowerMessage.includes('ola')) {
                return "Olá! Como posso ajudá-lo hoje? Estou aqui para responder suas perguntas!";
            } else if (lowerMessage.includes('como você está') || lowerMessage.includes('como esta')) {
                return "Estou funcionando perfeitamente! Como assistente virtual, estou sempre pronto para ajudar.";
            } else if (lowerMessage.includes('obrigado') || lowerMessage.includes('obrigada')) {
                return "De nada! Fico feliz em poder ajudar. Se tiver mais alguma dúvida, é só perguntar!";
            } else if (lowerMessage.includes('nome')) {
                return "Eu sou o DeepSeek, um assistente virtual baseado em IA. Fui criado para ajudar com uma variedade de tarefas!";
            } else if (lowerMessage.includes('horas') || lowerMessage.includes('hora')) {
                const now = new Date();
                return `Agora são ${now.getHours()}:${now.getMinutes().toString().padStart(2, '0')}.`;
            } else if (lowerMessage.includes('clima')) {
                return "Não tenho acesso a dados de clima em tempo real, mas posso ajudar a encontrar essa informação se você precisar!";
            } else if (lowerMessage.includes('ajuda')) {
                return "Claro! Posso ajudar com informações gerais, responder perguntas, explicar conceitos e muito mais. O que você gostaria de saber?";
            } else if (lowerMessage.includes('tchau') || lowerMessage.includes('adeus') || lowerMessage.includes('até logo')) {
                return "Até logo! Foi um prazer conversar com você. Volte sempre que precisar de ajuda!";
            } else {
                // Resposta padrão para mensagens não reconhecidas
                const responses = [
                    "Interessante! Pode me contar mais sobre isso?",
                    "Entendi. Como posso ajudar com essa questão?",
                    "Obrigado por compartilhar. Há algo específico que gostaria de saber?",
                    "Compreendo. Posso esclarecer alguma dúvida sobre esse assunto?",
                    "Vou pesquisar mais sobre isso. Enquanto isso, há alguma outra pergunta que posso responder?"
                ];
                return responses[Math.floor(Math.random() * responses.length)];
            }
        }
        
        // Testar conexão com a API
        async function testApiConnection(key) {
            statusIndicator.classList.remove('offline');
            statusIndicator.classList.add('connecting');
            statusText.textContent = "Testando conexão...";
            showApiTestResult('', '');
            
            try {
                const response = await fetch('https://api.deepseek.com/models', {
                    headers: {
                        'Authorization': `Bearer ${key}`
                    }
                });
                
                if (response.ok) {
                    apiKey = key;
                    isApiConfigured = true;
                    saveApiKey();
                    
                    statusIndicator.classList.remove('connecting');
                    statusText.textContent = "API Conectada e Funcionando";
                    showApiTestResult('Conexão com a API estabelecida com sucesso!', 'success');
                    
                    // Atualizar mensagem de boas-vindas
                    const welcomeMsg = document.querySelector('.bot-message .bot-bubble');
                    if (welcomeMsg) {
                        welcomeMsg.textContent = "Olá! Sou o assistente virtual DeepSeek. Estou conectado à API e pronto para ajudar!";
                    }
                } else {
                    throw new Error(`Erro: ${response.status}`);
                }
            } catch (error) {
                console.error('Erro ao testar API:', error);
                statusIndicator.classList.remove('connecting');
                statusIndicator.classList.add('offline');
                statusText.textContent = "Falha na conexão com a API";
                showApiTestResult(`Falha ao conectar com a API: ${error.message}`, 'error');
                isApiConfigured = false;
            }
        }
        
        // Usar a API key fornecida
        function useProvidedApiKey() {
            apiKey = providedApiKey;
            isApiConfigured = true;
            saveApiKey();
            testApiConnection(providedApiKey);
        }
        
        // Funções de gerenciamento de API
        function loadApiKey() {
            const savedApiKey = localStorage.getItem('deepseekApiKey');
            if (savedApiKey) {
                apiKey = savedApiKey;
                isApiConfigured = true;
                testApiConnection(savedApiKey);
            }
        }
        
        function saveApiKey() {
            localStorage.setItem('deepseekApiKey', apiKey);
        }
        
        function updateApiStatus() {
            if (isApiConfigured) {
                statusIndicator.classList.remove('offline');
                statusText.textContent = "API Configurada";
            } else {
                statusIndicator.classList.add('offline');
                statusText.textContent = "API não configurada";
            }
        }
        
        function showApiTestResult(message, type) {
            apiTestResult.textContent = message;
            apiTestResult.className = 'api-test-result';
            if (type) {
                apiTestResult.classList.add(type);
            }
        }
        
        function updateTokenInfo() {
            tokenInfo.textContent = `Tokens usados: ${totalTokens.toLocaleString()}`;
        }
        
        function estimateTokens(text) {
            // Estimativa simples: ~4 caracteres por token
            return Math.ceil(text.length / 4);
        }
    </script>
</body>