Deploy limpo do AutisMind AI API com gpt2-small-portuguese

README.md

@@ -1,13 +1,82 @@
 ---
-title: Autismind Ai
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
+title: AutisMind AI API Backend
+emoji: 🧠
+colorFrom: green
+colorTo: blue
 sdk: gradio
-sdk_version: 5.0.1
+python_version: 3.10 # OU 3.11, OU 3.12 (versões mais recentes e estáveis)
 app_file: app.py
-pinned: false
-license: mit
+requirements_file: requirements.txt
+command: uvicorn app:app --host 0.0.0.0 --port 7860
 ---
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# AutisMind AI API Backend
+
+Este Hugging Face Space hospeda o servidor Python da API de Inteligência Artificial para o projeto **AutisMind**.
+
+Ele fornece uma API RESTful para gerar respostas de texto em português e realizar análises básicas de conversas, focando no desenvolvimento socioemocional de pessoas neurodivergentes.
+
+### **Modelo de Linguagem Utilizado:**
+
+O modelo de linguagem utilizado é o **`pierreguillou/gpt2-small-portuguese`**, que é baixado dinamicamente do Hugging Face Hub durante a inicialização do Space. Este modelo é otimizado para o idioma português e é leve o suficiente para ser executado no plano gratuito do Hugging Face Spaces.
+
+### **Endpoints da API:**
+
+1.  **`POST /generate-response`**
+    * **Função:** Gera uma resposta de texto da IA para uma mensagem do usuário, considerando um histórico de conversa e uma personalidade de personagem. Também realiza uma análise básica da mensagem do usuário.
+    * **URL de Exemplo (após o deploy):** `https://SEU_NOME_DE_USUARIO-SEU_NOME_DO_SPACE.hf.space/generate-response`
+    * **Corpo da Requisição (JSON):**
+        ```json
+        {
+            "message": "Qual é a sua cor favorita?",
+            "history": [
+                {
+                    "role": "user",
+                    "content": "Olá, tudo bem?"
+                },
+                {
+                    "role": "assistant",
+                    "content": "Olá! Estou bem, obrigado. Como posso ajudar você hoje?"
+                }
+            ],
+            "persona": "Você é um robô de apoio amigável chamado 'Robô Guia', sempre com uma atitude positiva e prestativa.",
+            "chatId": "chat-id-exemplo"
+        }
+        ```
+    * **Exemplo de Resposta (JSON):**
+        ```json
+        {
+            "ai_response": "Como um robô guia, não tenho uma cor favorita como os humanos, mas eu adoro a cor azul, pois me lembra do céu e da vasta quantidade de informações que posso processar!",
+            "analysis": {
+                "sentiment": "positivo",
+                "emotion": "alegria"
+            }
+        }
+        ```
+
+2.  **`GET /health`**
+    * **Função:** Verifica o status do servidor da API e se o modelo de IA foi carregado com sucesso.
+    * **URL de Exemplo (após o deploy):** `https://SEU_NOME_DE_USUARIO-SEU_NOME_DO_SPACE.hf.space/health`
+    * **Exemplo de Resposta (JSON):**
+        ```json
+        {
+            "status": "ok",
+            "model_loaded": true
+        }
+        ```
+
+### **Como Usar:**
+
+1.  **Crie um Space no Hugging Face** com o SDK "Gradio" (conforme instruído, para usar o ambiente Python).
+2.  **Clone este repositório** para a sua máquina local.
+3.  **Copie os arquivos** `app.py`, `requirements.txt`, `.env` (se tiver outras variáveis) e este `README.md` para o diretório raiz do Space clonado. **Não inclua arquivos de modelo grandes (`.gguf` ou `.bin`)**.
+4.  **Faça o `git add .`, `git commit` e `git push`** das suas alterações para o Space.
+5.  O Hugging Face irá construir e iniciar sua API. Monitore a aba "Logs" para verificar o progresso e o status.
+6.  Uma vez que o Space esteja "Running", use as URLs fornecidas acima para integrar com seu servidor Express e front-end.
+
+---
+
+**Lembre-se de:**
+
+* Substituir `SEU_NOME_DE_USUARIO` e `SEU_NOME_DO_SPACE` pelas informações reais do seu Space nas URLs de exemplo.
+* Verificar a `python_version` no cabeçalho YAML (`3.10` é um bom padrão, mas confirme a sua com `python3 --version` no terminal).

app.py

@@ -1,64 +1,217 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
+import os
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import List, Dict, Union, Optional
+
+# --- NOVAS IMPORTAÇÕES PARA TRANSFORMERS E PyTorch ---
+try:
+    from transformers import AutoTokenizer, AutoModelForCausalLM
+    import torch
+except ImportError:
+    print("Erro: As bibliotecas 'transformers' ou 'torch' não foram encontradas.")
+    print("Certifique-se de instalá-las: pip install transformers torch")
+    exit(1)
+
+# Carregar variáveis de ambiente (MODEL_PATH não será mais usado diretamente aqui)
+load_dotenv()
+
+# --- Configurações do Modelo ---
+# O nome do modelo no Hugging Face Hub
+HF_MODEL_ID = "pierreguillou/gpt2-small-portuguese"
+
+# Instâncias globais para o modelo e tokenizer
+tokenizer: Optional[AutoTokenizer] = None
+model: Optional[AutoModelForCausalLM] = None
+
+# --- Inicialização do FastAPI ---
+app = FastAPI(
+    title="AutisMind AI Server",
+    description="API para interação com o modelo GPT2-small-portuguese e análise de conversas.",
+    version="1.0.0",
+)
+
+# --- Configuração CORS ---
+origins = [
+    "http://localhost:3000",
+    "http://localhost:5000",
+    "http://127.0.0.1:3000",
+    "http://127.0.0.1:5000",
+    # Adicione aqui os domínios do seu frontend e do Express API quando estiverem em produção
+    # Ex: "https://seunome-seu-space-name.hf.space"
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
+# --- Modelos Pydantic para Requisições e Respostas (Mantidos) ---
+class ChatMessage(BaseModel):
+    role: str # "user" ou "assistant"
+    content: str
+
+class ChatRequest(BaseModel):
+    message: str = Field(..., description="A mensagem do usuário.")
+    history: List[ChatMessage] = Field(default_factory=list, description="Histórico da conversa (opcional).")
+    persona: str = Field(
+        "Você é um assistente útil e amigável. Responda de forma clara e empática.",
+        description="A personalidade do personagem para a IA."
+    )
+    chatId: Optional[str] = Field(None, description="ID do chat para contexto (não usado pela IA, mas pode ser útil para logs).")
+
+class AnalysisResult(BaseModel):
+    sentiment: str = Field("neutro", description="Sentimento da mensagem (positivo, negativo, neutro).")
+    emotion: str = Field("desconhecida", description="Emoção detectada (ex: alegria, tristeza, raiva).")
+
+class ChatResponse(BaseModel):
+    ai_response: str = Field(..., description="A resposta gerada pela IA.")
+    analysis: AnalysisResult = Field(..., description="Resultados da análise da mensagem do usuário ou da resposta da IA.")
+
+# --- Evento de inicialização da aplicação (carrega o modelo) ---
+@app.on_event("startup")
+async def startup_event():
+    global model, tokenizer
+    print(f"Carregando modelo Transformers: {HF_MODEL_ID}")
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(HF_MODEL_ID)
+        # O GPT-2 não tem um token PAD padrão, define um.
+        # 50256 é o token EOS padrão do GPT-2, pode ser usado como PAD também.
+        tokenizer.pad_token = tokenizer.eos_token 
+        
+        # Ajusta o tamanho máximo de sequência do tokenizer para algo comum como 1024
+        tokenizer.model_max_length = 1024
+
+        model = AutoModelForCausalLM.from_pretrained(HF_MODEL_ID)
+        model.eval() # Coloca o modelo em modo de avaliação (desativa dropout, etc.)
+        
+        # Tenta mover o modelo para a GPU se disponível e compatível com PyTorch/Transformers
+        if torch.cuda.is_available():
+            model.to("cuda")
+            print("Modelo movido para GPU!")
+        else:
+            print("Modelo carregado na CPU.")
+
+        print(f"Modelo {HF_MODEL_ID} carregado com sucesso!")
+    except Exception as e:
+        print(f"Erro ao carregar o modelo {HF_MODEL_ID}: {e}")
+        raise RuntimeError(f"Falha ao carregar o modelo LLM: {e}")
+
+# --- Endpoint de Saúde ---
+@app.get("/health")
+async def health_check():
+    if model and tokenizer: # Verifica se ambos foram carregados
+        return {"status": "ok", "model_loaded": True}
+    return {"status": "loading", "model_loaded": False}
+
+# --- Endpoint Principal para Geração de Resposta e Análise ---
+@app.post("/generate-response", response_model=ChatResponse)
+async def generate_ai_response(request: ChatRequest):
+    global model, tokenizer
+    if not model or not tokenizer:
+        raise HTTPException(status_code=503, detail="Modelo AI ainda não carregado. Tente novamente em breve.")
+
+    user_message = request.message
+    chat_history = request.history
+    character_persona = request.persona
+
+    # --- Construir o Prompt para GPT-2 ---
+    # GPT-2 é um modelo generativo, não segue o formato <|system|> como Phi.
+    # A persona e o histórico são concatenados.
+    prompt_parts = []
+    # Inclui a persona no início do prompt, como uma instrução inicial para o modelo.
+    prompt_parts.append(f"{character_persona}\n\n") 
+    
+    # Adicionar histórico da conversa
+    # É importante limitar o histórico para não exceder o model_max_length (1024 tokens para GPT-2 small).
+    # Uma boa estratégia é adicionar o histórico mais recente.
+    # O GPT-2 não tem roles, então formatamos como um diálogo.
+    for turn in chat_history[-5:]: # Inclui os últimos 5 turnos (adaptar conforme necessidade)
+        if turn.role == 'user':
+            prompt_parts.append(f"Usuário: {turn.content}\n")
+        elif turn.role == 'assistant':
+            prompt_parts.append(f"Assistente: {turn.content}\n")
+    
+    # Adiciona a mensagem atual do usuário e pede para a IA responder
+    prompt_parts.append(f"Usuário: {user_message}\nAssistente:") 
+    
+    full_prompt = "".join(prompt_parts)
+
+    try:
+        # Codifica o prompt para tokens
+        # return_tensors="pt" para PyTorch
+        # max_length para garantir que o prompt não exceda o limite do modelo
+        inputs = tokenizer(
+            full_prompt, 
+            return_tensors="pt", 
+            max_length=tokenizer.model_max_length, 
+            truncation=True
+        )
+        
+        # Mover os inputs para a GPU se o modelo estiver na GPU
+        if torch.cuda.is_available():
+            inputs = {k: v.to("cuda") for k, v in inputs.items()}
+
+        # Gerar a resposta
+        # pad_token_id: O token usado para preencher sequências, aqui usamos o EOS token do GPT-2
+        # do_sample=True: Habilita amostragem (para criatividade)
+        # top_k, top_p: Métodos de amostragem para controlar a diversidade da resposta
+        # max_new_tokens: O número máximo de novos tokens que a IA pode gerar APÓS o prompt
+        sample_outputs = model.generate(
+            inputs.input_ids,
+            pad_token_id=tokenizer.pad_token_id, # Usando o token de pad que definimos
+            do_sample=True,
+            max_new_tokens=150, # Gera até 150 tokens novos de resposta
+            temperature=0.7,
+            top_k=50,
+            top_p=0.9,
+            num_return_sequences=1
+        )
+        
+        # Decodificar a resposta gerada
+        # skip_special_tokens=True: Remove tokens especiais como <bos>, <eos>, <pad>
+        generated_text = tokenizer.decode(sample_outputs[0], skip_special_tokens=True)
+        
+        # --- Pós-processamento da Resposta do GPT-2 ---
+        # GPT-2 vai gerar o prompt INTEIRO MAIS a resposta.
+        # Precisamos remover o prompt original para obter apenas a resposta do "Assistente:".
+        # Isso pode ser um pouco delicado e pode precisar de ajustes finos dependendo da saída real do modelo.
+        ai_response_raw = generated_text.replace(full_prompt, "").strip()
+
+        # O GPT-2 pode continuar gerando texto ou até começar um "Usuário:" de novo.
+        # Tentamos cortar a resposta na primeira ocorrência de "Usuário:" ou "Assistente:" para evitar isso.
+        if "\nUsuário:" in ai_response_raw:
+            ai_response = ai_response_raw.split("\nUsuário:")[0].strip()
+        elif "\nAssistente:" in ai_response_raw:
+            ai_response = ai_response_raw.split("\nAssistente:")[0].strip()
+        else:
+            ai_response = ai_response_raw
+
+
+        # --- Lógica de Análise (Mantida) ---
+        analysis_result = AnalysisResult() 
+        user_message_lower = user_message.lower()
+        if "triste" in user_message_lower or "chateado" in user_message_lower or "mal" in user_message_lower:
+            analysis_result.sentiment = "negativo"
+            analysis_result.emotion = "tristeza"
+        elif "feliz" in user_message_lower or "alegre" in user_message_lower or "bom" in user_message_lower:
+            analysis_result.sentiment = "positivo"
+            analysis_result.emotion = "alegria"
+        else:
+            analysis_result.sentiment = "neutro"
+            analysis_result.emotion = "desconhecida"
+        
+        return ChatResponse(ai_response=ai_response, analysis=analysis_result)
+
+    except Exception as e:
+        print(f"Erro na geração da IA: {e}")
+        raise HTTPException(status_code=500, detail=f"Erro interno do servidor AI: {str(e)}")
 
+# --- Executar o Servidor (apenas para teste direto via Python) ---
 if __name__ == "__main__":
-    demo.launch()
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=5001)

requirements.txt

@@ -1 +1,6 @@
-huggingface_hub==0.25.2
+fastapi
+uvicorn
+python-dotenv
+transformers
+torch # ou tensorflow, dependendo da sua preferência, mas transformers usa pytorch por padrão
+pydantic>=2.0