Add application file

Dockerfile

@@ -0,0 +1,32 @@
+# Leia: https://huggingface.co/docs/hub/spaces-sdks-docker
+FROM python:3.10-slim
+
+# Usuário não-root (boa prática em Spaces)
+RUN useradd -m -u 1000 user
+USER root
+
+ENV PIP_NO_CACHE_DIR=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PATH="/home/user/.local/bin:$PATH"
+
+# Dependências nativas mínimas (pdf parsing)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential poppler-utils \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY --chown=user:user requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user:user . /app
+USER user
+
+# Variáveis (podem ser sobrescritas nas "Variables" do Space)
+ENV PORT=7860
+ENV GROQ_MODEL_ID=deepseek-r1-distill-llama-70b
+ENV TEMPERATURE=0.7
+
+# O Space escuta em 7860
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -7,4 +7,26 @@ sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# RecrAI — API (FastAPI + Groq) para Análise de Currículos
+
+API que analisa CVs (PDF ou texto) contra uma vaga e retorna JSON estruturado (inclui `score`), pronta para rodar em Hugging Face Spaces via Docker.
+
+## Endpoints
+
+### GET /health
+Retorna status da API.
+
+### POST /analyze_cv (multipart/form-data)
+Campos:
+- `job` (string) — descrição completa da vaga (obrigatório)
+- `cv_text` (string) — texto do currículo (opcional se `file` for enviado)
+- `file` (file/pdf) — PDF do currículo (opcional se `cv_text` for enviado)
+
+### POST /analyze_cv_batch (application/json)
+```json
+{
+  "items": [
+    { "job": "texto da vaga", "cv_text": "texto do cv" },
+    { "job": "texto da vaga", "cv_pdf_b64": "<PDF em base64>" }
+  ]
+}

app.py

@@ -0,0 +1,61 @@
+import os
+import uvicorn
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List, Optional
+
+from models_schemas import AnalyzeResponse, AnalyzeBatchRequest
+from llm_client import analyze_cv_with_llm
+from parsers import extract_text_from_pdf
+
+app = FastAPI(title="RecrAI API", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], allow_credentials=True,
+    allow_methods=["*"], allow_headers=["*"]
+)
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+@app.post("/analyze_cv", response_model=AnalyzeResponse)
+async def analyze_cv_endpoint(
+    job: str = Form(..., description="Descrição completa da vaga"),
+    cv_text: Optional[str] = Form(None, description="Texto do currículo (alternativa a PDF)"),
+    file: Optional[UploadFile] = File(None, description="Arquivo PDF do currículo")
+):
+    if not cv_text and not file:
+        raise HTTPException(status_code=400, detail="Envie 'cv_text' ou 'file' (PDF).")
+
+    if file:
+        if not file.filename.lower().endswith(".pdf"):
+            raise HTTPException(status_code=415, detail="Apenas PDF é suportado no 'file'.")
+        pdf_bytes = await file.read()
+        cv_text = extract_text_from_pdf(pdf_bytes)
+
+    if not cv_text or not cv_text.strip():
+        raise HTTPException(status_code=422, detail="Não foi possível extrair texto do currículo.")
+
+    result = analyze_cv_with_llm(cv_text=cv_text, job_details=job)
+    return result
+
+@app.post("/analyze_cv_batch", response_model=List[AnalyzeResponse])
+async def analyze_cv_batch_endpoint(payload: AnalyzeBatchRequest):
+    results = []
+    for item in payload.items:
+        if not item.cv_text and not item.cv_pdf_b64:
+            raise HTTPException(status_code=400, detail="Cada item precisa de cv_text ou cv_pdf_b64.")
+        cv_text = item.cv_text
+        if not cv_text and item.cv_pdf_b64:
+            import base64
+            pdf_bytes = base64.b64decode(item.cv_pdf_b64)
+            cv_text = extract_text_from_pdf(pdf_bytes)
+        res = analyze_cv_with_llm(cv_text=cv_text, job_details=item.job)
+        results.append(res)
+    return results
+
+if __name__ == "__main__":
+    uvicorn.run("app:app", host="0.0.0.0", port=int(os.getenv("PORT", "7860")))

data/jobs.json

@@ -0,0 +1,30 @@
+[
+  {
+    "id": 1,
+    "title": "Desenvolvedor(a) Full Stack Pleno",
+    "description": "Desenvolver e evoluir aplicações (front/back), integrações e CI/CD.",
+    "details": "React, Node, APIs REST, testes, boas práticas, cloud.",
+    "requirements": [
+      "React",
+      "Node",
+      "JavaScript",
+      "TypeScript",
+      "APIs REST",
+      "SQL",
+      "Docker"
+    ]
+  },
+  {
+    "id": 2,
+    "title": "Cientista de Dados Pleno",
+    "description": "Modelagem preditiva, EDA, métricas e MLOps.",
+    "details": "Pipelines, versionamento, documentação, comunicação.",
+    "requirements": [
+      "Pandas",
+      "Scikit-learn",
+      "Feature Engineering",
+      "Métricas",
+      "MLOps"
+    ]
+  }
+]

llm_client.py

@@ -0,0 +1,65 @@
+import json
+import os
+from typing import Dict, Any
+from langchain_groq import ChatGroq
+from langchain_core.prompts import ChatPromptTemplate
+from models_schemas import AnalyzeResponse
+from prompts import PROMPT_TEMPLATE, SCHEMA_JSON, PROMPT_SCORE
+
+GROQ_MODEL_ID = os.getenv("GROQ_MODEL_ID", "deepseek-r1-distill-llama-70b")
+TEMPERATURE = float(os.getenv("TEMPERATURE", "0.7"))
+
+def _load_llm():
+    return ChatGroq(
+        model=GROQ_MODEL_ID,
+        temperature=TEMPERATURE,
+        max_tokens=None,
+        timeout=None,
+        max_retries=2,
+    )
+
+def _strip_think(text: str) -> str:
+    if "</think>" in text:
+        return text.split("</think>")[-1].strip()
+    return text.strip()
+
+def _force_schema_fields(d: Dict[str, Any]) -> Dict[str, Any]:
+    keys = [
+        "name","area","summary","skills","education","interview_questions",
+        "strengths","areas_for_development","important_considerations",
+        "final_recommendations","score"
+    ]
+    for k in keys:
+        if k not in d:
+            d[k] = [] if k in {
+                "skills","interview_questions","strengths",
+                "areas_for_development","important_considerations"
+            } else (0.0 if k == "score" else "")
+    return d
+
+def analyze_cv_with_llm(cv_text: str, job_details: str) -> AnalyzeResponse:
+    llm = _load_llm()
+    prompt = ChatPromptTemplate.from_template(PROMPT_TEMPLATE)
+    chain = prompt | llm
+    output = chain.invoke({
+        "schema": SCHEMA_JSON,
+        "prompt_score": PROMPT_SCORE,
+        "cv": cv_text,
+        "job": job_details
+    })
+
+    raw = _strip_think(output.content)
+
+    start = raw.find("{")
+    end = raw.rfind("}")
+    if start == -1 or end == -1:
+        return AnalyzeResponse()
+
+    json_str = raw[start:end+1]
+    try:
+        data = json.loads(json_str)
+    except Exception:
+        return AnalyzeResponse()
+
+    data = _force_schema_fields(data)
+    return AnalyzeResponse(**data)

models_schemas.py

@@ -0,0 +1,30 @@
+from typing import List, Optional
+from pydantic import BaseModel, Field, validator
+
+class AnalyzeResponse(BaseModel):
+    name: Optional[str] = ""
+    area: Optional[str] = ""
+    summary: Optional[str] = ""
+    skills: List[str] = Field(default_factory=list)
+    education: Optional[str] = ""
+    interview_questions: List[str] = Field(default_factory=list)
+    strengths: List[str] = Field(default_factory=list)
+    areas_for_development: List[str] = Field(default_factory=list)
+    important_considerations: List[str] = Field(default_factory=list)
+    final_recommendations: Optional[str] = ""
+    score: float = 0.0
+
+    @validator("score", pre=True, always=True)
+    def coerce_score(cls, v):
+        try:
+            return float(v)
+        except Exception:
+            return 0.0
+
+class AnalyzeBatchItem(BaseModel):
+    job: str
+    cv_text: Optional[str] = None
+    cv_pdf_b64: Optional[str] = None
+
+class AnalyzeBatchRequest(BaseModel):
+    items: List[AnalyzeBatchItem]

parsers.py

@@ -0,0 +1,29 @@
+from typing import Optional
+
+def extract_text_from_pdf(pdf_bytes: bytes) -> str:
+    """
+    Tenta PyMuPDF (fitz). Se falhar, tenta pdfminer.six (fallback).
+    """
+    text: Optional[str] = None
+
+    # 1) PyMuPDF
+    try:
+        import fitz  # PyMuPDF
+        doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+        parts = []
+        for page in doc:
+            parts.append(page.get_text())
+        text = "\n".join(parts).strip()
+    except Exception:
+        text = None
+
+    # 2) pdfminer fallback
+    if not text:
+        try:
+            from io import BytesIO
+            from pdfminer.high_level import extract_text as pdfminer_extract
+            text = pdfminer_extract(BytesIO(pdf_bytes)).strip()
+        except Exception:
+            text = ""
+
+    return text or ""

prompts.py

@@ -0,0 +1,51 @@
+SCHEMA_JSON = """
+{
+  "name": "Nome completo do candidato",
+  "area": "Área ou setor principal onde o candidato atua. Classifique em apenas uma: Desenvolvimento, Marketing, Vendas, Financeiro, Administrativo, Outros",
+  "summary": "Resumo objetivo sobre o perfil profissional do candidato",
+  "skills": ["competência 1", "competência 2", "..."],
+  "education": "Resumo da formação acadêmica mais relevante",
+  "interview_questions": ["Pelo menos 3 perguntas úteis para entrevista com base no currículo, para esclarecer algum ponto ou explorar melhor"],
+  "strengths": ["Pontos fortes e aspectos que indicam alinhamento com o perfil ou vaga desejada"],
+  "areas_for_development": ["Pontos que indicam possíveis lacunas, fragilidades ou necessidades de desenvolvimento"],
+  "important_considerations": ["Observações específicas que merecem verificação ou cuidado adicional"],
+  "final_recommendations": "Resumo avaliativo final com sugestões de próximos passos (ex: seguir com entrevista, indicar para outra vaga)",
+  "score": 0.0
+}
+"""
+
+PROMPT_SCORE = """
+Com base na vaga específica, calcule a pontuação final (de 0.0 a 10.0).
+O retorno para esse campo deve conter apenas a pontuação final (x.x) sem mais nenhum texto ou anotação.
+Seja justo e rigoroso ao atribuir as notas. A nota 10.0 só deve ser atribuída para candidaturas que superem todas as expectativas da vaga.
+
+Critérios de avaliação:
+1. Experiência (Peso: 35% do total): Análise de posições anteriores, tempo de atuação e similaridade com as responsabilidades da vaga.
+2. Habilidades Técnicas (Peso: 25% do total): Verifique o alinhamento das habilidades técnicas com os requisitos mencionados na vaga.
+3. Educação (Peso: 15% do total): Avalie a relevância da graduação/certificações para o cargo, incluindo instituições e anos de estudo.
+4. Pontos Fortes (Peso: 15% do total): Avalie a relevância dos pontos fortes (ou alinhamentos) para a vaga.
+5. Pontos Fracos (Desconto de até 10%): Avalie a gravidade dos pontos fracos (ou desalinhamentos) para a vaga.
+"""
+
+PROMPT_TEMPLATE = """
+Você é um especialista em Recursos Humanos com vasta experiência em análise de currículos.
+Sua tarefa é analisar o conteúdo a seguir e extrair os dados conforme o formato abaixo, para cada um dos campos.
+Responda apenas com o JSON estruturado e utilize somente essas chaves. Cuide para que os nomes das chaves sejam exatamente esses.
+Não adicione explicações ou anotações fora do JSON.
+Schema desejado:
+{schema}
+
+---
+Para o cálculo do campo score:
+{prompt_score}
+
+---
+
+Currículo a ser analisado:
+'{cv}'
+
+---
+
+Vaga que o candidato está se candidatando:
+'{job}'
+"""

requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.115.0
+uvicorn[standard]==0.30.6
+python-multipart==0.0.9
+
+pydantic==2.9.2
+langchain==0.2.16
+langchain-groq==0.1.5
+
+PyMuPDF==1.24.11
+pdfminer.six==20231228