Deploy LFM2-8B-A1B local + multilingual models

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.12
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user app.py .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,71 @@
+---
+title: Multi-Models
+emoji: 🤖
+colorFrom: yellow
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+short_description: API Multi-Modal - Chat, Visão, Embeddings, Classificação
+---
+
+# 🤖 DGGirl API v4 - Multi-Modal
+
+API compatível com OpenAI para uso no **n8n** e outras integrações.
+
+## 🎯 Endpoints Disponíveis
+
+| Endpoint | Método | Descrição |
+|----------|--------|-----------|
+| `/v1/chat/completions` | POST | Chat inteligente + Análise de imagens |
+| `/v1/embeddings` | POST | Vetores semânticos (RAG) |
+| `/v1/classify` | POST | Classificação zero-shot |
+| `/v1/summarize` | POST | Resumir textos |
+| `/v1/sentiment` | POST | Análise de sentimento |
+| `/v1/models` | GET | Listar modelos |
+| `/health` | GET | Status da API |
+
+## 🧠 Modelos Utilizados
+
+- **Chat**: `LiquidAI/LFM2-8B-A1B` - Rápido e versátil
+- **Visão**: `google/gemma-3-27b-it` - Análise de imagens
+- **Embeddings**: `BAAI/bge-m3` - Vetores multilíngue
+- **Classificação**: `facebook/bart-large-mnli` - Zero-shot
+- **Sumarização**: `facebook/bart-large-cnn`
+- **Sentimento**: `cardiffnlp/twitter-roberta-base-sentiment-latest`
+
+## 📋 Exemplos de Uso
+
+### Chat
+```bash
+curl -X POST "https://SEU-SPACE.hf.space/v1/chat/completions" \
+  -H "Authorization: Bearer SEU_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"messages": [{"role": "user", "content": "Olá!"}]}'
+```
+
+### Classificar Intenção
+```bash
+curl -X POST "https://SEU-SPACE.hf.space/v1/classify" \
+  -H "Authorization: Bearer SEU_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "Quero cancelar meu pedido", "labels": ["pedido", "cancelamento", "dúvida"]}'
+```
+
+### Análise de Sentimento
+```bash
+curl -X POST "https://SEU-SPACE.hf.space/v1/sentiment" \
+  -H "Authorization: Bearer SEU_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "Estou muito satisfeito com o atendimento!"}'
+```
+
+## ⚙️ Configuração
+
+Defina as variáveis de ambiente no Space:
+- `HF_TOKEN`: Seu token do Hugging Face
+- `API_KEY`: (Opcional) Chave de API personalizada
+
+## 📚 Documentação
+
+Acesse `/docs` para a documentação Swagger interativa.

app.py

@@ -0,0 +1,525 @@
+import os
+import uuid
+import time
+import hashlib
+import traceback
+from datetime import datetime
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+from huggingface_hub import InferenceClient
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# ============ Configuração ============
+
+HF_TOKEN = os.environ.get("HF_TOKEN")
+API_KEY = os.environ.get("API_KEY", HF_TOKEN)
+
+# ============ Modelo Local - LFM2-8B-A1B (CPU) ============
+
+print("🔄 Carregando LFM2-8B-A1B localmente...")
+LOCAL_MODEL_NAME = "LiquidAI/LFM2-8B-A1B"
+
+# Carregar tokenizer e modelo para CPU
+chat_tokenizer = AutoTokenizer.from_pretrained(LOCAL_MODEL_NAME, token=HF_TOKEN, trust_remote_code=True)
+chat_model = AutoModelForCausalLM.from_pretrained(
+    LOCAL_MODEL_NAME,
+    token=HF_TOKEN,
+    trust_remote_code=True,
+    torch_dtype=torch.float16,  # Economia de memória
+    device_map="cpu",
+    low_cpu_mem_usage=True
+)
+print("✅ LFM2-8B-A1B carregado com sucesso!")
+
+# ============ Clientes de Modelos (Inference API) ============
+
+# Visão - Análise de imagens (Inference API)
+vision_client = InferenceClient(token=HF_TOKEN, model="google/gemma-3-27b-it")
+
+# Embeddings - Vetores semânticos (Inference API)
+embed_client = InferenceClient(token=HF_TOKEN, model="BAAI/bge-m3")
+
+# Classificação Zero-Shot (Multilíngue - PT/EN/ES...)
+classify_client = InferenceClient(token=HF_TOKEN, model="joeddav/xlm-roberta-large-xnli")
+
+# Sumarização (Multilíngue - 45 idiomas incluindo PT)
+summarize_client = InferenceClient(token=HF_TOKEN, model="csebuetnlp/mT5_multilingual_XLSum")
+
+# Análise de Sentimento (Multilíngue - PT/EN/ES...)
+sentiment_client = InferenceClient(token=HF_TOKEN, model="lxyuan/distilbert-base-multilingual-cased-sentiments-student")
+
+
+# ============ Função de Chat Local ============
+
+def generate_local_chat(messages, max_tokens=1024, temperature=0.7):
+    """Gera resposta usando o modelo local LFM2-8B-A1B"""
+    # Formatar mensagens no formato ChatML
+    formatted_prompt = ""
+    for msg in messages:
+        role = msg.get("role", "user")
+        content = msg.get("content", "")
+        if isinstance(content, list):
+            # Extrair texto de conteúdo multimodal
+            content = " ".join([item.get("text", "") for item in content if item.get("type") == "text"])
+        formatted_prompt += f"<|im_start|>{role}\n{content}<|im_end|>\n"
+    formatted_prompt += "<|im_start|>assistant\n"
+    
+    # Tokenizar
+    inputs = chat_tokenizer(formatted_prompt, return_tensors="pt")
+    
+    # Gerar resposta
+    with torch.no_grad():
+        outputs = chat_model.generate(
+            inputs.input_ids,
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+            do_sample=temperature > 0,
+            pad_token_id=chat_tokenizer.eos_token_id,
+            eos_token_id=chat_tokenizer.eos_token_id
+        )
+    
+    # Decodificar resposta
+    response = chat_tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+    return response.strip()
+
+# ============ Cache ============
+
+response_cache = {}
+CACHE_MAX_SIZE = 500
+CACHE_TTL_SECONDS = 3600
+
+def get_cache_key(content, task):
+    data = str(content) + task
+    return hashlib.md5(data.encode()).hexdigest()
+
+def get_cached_response(key):
+    if key in response_cache:
+        entry = response_cache[key]
+        if time.time() - entry["timestamp"] < CACHE_TTL_SECONDS:
+            return entry["response"]
+        else:
+            del response_cache[key]
+    return None
+
+def set_cached_response(key, response):
+    if len(response_cache) >= CACHE_MAX_SIZE:
+        oldest_key = min(response_cache.keys(), key=lambda k: response_cache[k]["timestamp"])
+        del response_cache[oldest_key]
+    response_cache[key] = {"response": response, "timestamp": time.time()}
+
+def verify_api_key(request: Request) -> bool:
+    auth = request.headers.get("Authorization", "")
+    return auth.startswith("Bearer ") and auth[7:] == API_KEY
+
+def has_image_content(messages):
+    for msg in messages:
+        content = msg.get("content", [])
+        if isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict) and item.get("type") == "image_url":
+                    return True
+    return False
+
+# ============ FastAPI ============
+
+app = FastAPI(
+    title="DGGirl Multi-Modal API",
+    description="API compatível com OpenAI para chat, visão, embeddings, classificação, sumarização e sentimento",
+    version="4.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ============ Página Inicial ============
+
+@app.get("/", response_class=HTMLResponse)
+async def home():
+    endpoints_html = """
+        <div class="endpoint"><span class="method">POST</span> <code>/v1/chat/completions</code><p>💬 Chat inteligente (LFM2-8B) + Visão (Gemma 3)</p></div>
+        <div class="endpoint"><span class="method">POST</span> <code>/v1/embeddings</code><p>🔢 Vetores semânticos para RAG (BGE-M3)</p></div>
+        <div class="endpoint"><span class="method">POST</span> <code>/v1/classify</code><p>🏷️ Classificação zero-shot de textos</p></div>
+        <div class="endpoint"><span class="method">POST</span> <code>/v1/summarize</code><p>📝 Resumir textos longos</p></div>
+        <div class="endpoint"><span class="method">POST</span> <code>/v1/sentiment</code><p>😊 Análise de sentimento</p></div>
+    """
+    return f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>DGGirl API v4</title>
+        <style>
+            body {{ font-family: 'Segoe UI', Tahoma, sans-serif; max-width: 900px; margin: 40px auto; padding: 20px; background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%); min-height: 100vh; }}
+            .container {{ background: rgba(255,255,255,0.95); padding: 40px; border-radius: 20px; box-shadow: 0 10px 40px rgba(0,0,0,0.3); }}
+            h1 {{ color: #1a73e8; border-bottom: 3px solid #4285f4; padding-bottom: 15px; margin-bottom: 20px; }}
+            .status {{ background: linear-gradient(135deg, #00c853, #69f0ae); color: white; padding: 8px 16px; border-radius: 25px; font-weight: bold; font-size: 0.9em; display: inline-block; }}
+            .endpoint {{ background: #f8f9fa; padding: 18px; margin: 12px 0; border-radius: 12px; border-left: 6px solid #4285f4; transition: transform 0.2s; }}
+            .endpoint:hover {{ transform: translateX(5px); background: #e8f0fe; }}
+            .method {{ background: #d93025; color: white; padding: 4px 10px; border-radius: 5px; font-weight: bold; font-size: 0.85em; }}
+            code {{ background: #e8eaed; padding: 4px 10px; border-radius: 6px; font-family: 'Consolas', monospace; font-size: 0.95em; }}
+            .models {{ background: #e3f2fd; padding: 20px; border-radius: 12px; margin-top: 20px; }}
+            .models h3 {{ margin-top: 0; color: #1565c0; }}
+            .model-tag {{ display: inline-block; background: #1a73e8; color: white; padding: 5px 12px; border-radius: 15px; margin: 4px; font-size: 0.85em; }}
+            a {{ color: #1a73e8; text-decoration: none; }}
+            a:hover {{ text-decoration: underline; }}
+            .stats {{ display: flex; gap: 20px; margin-top: 20px; }}
+            .stat {{ background: #fff3e0; padding: 15px; border-radius: 10px; flex: 1; text-align: center; }}
+            .stat-value {{ font-size: 1.5em; font-weight: bold; color: #e65100; }}
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>🤖 DGGirl API v4 - Multi-Modal</h1>
+            <p>Status: <span class="status">● OPERACIONAL</span></p>
+            
+            {endpoints_html}
+            
+            <div class="models">
+                <h3>🧠 Modelos Ativos</h3>
+                <span class="model-tag">LiquidAI/LFM2-8B-A1B</span>
+                <span class="model-tag">Gemma 3 27B Vision</span>
+                <span class="model-tag">BGE-M3 Embeddings</span>
+                <span class="model-tag">XLM-RoBERTa Classification</span>
+                <span class="model-tag">mT5 Summarization</span>
+                <span class="model-tag">DistilBERT Sentiment</span>
+            </div>
+            
+            <div class="stats">
+                <div class="stat">
+                    <div class="stat-value">{len(response_cache)}</div>
+                    <div>Cache Items</div>
+                </div>
+                <div class="stat">
+                    <div class="stat-value">6</div>
+                    <div>Endpoints</div>
+                </div>
+                <div class="stat">
+                    <div class="stat-value">6</div>
+                    <div>Modelos</div>
+                </div>
+            </div>
+            
+            <p style="margin-top: 25px; text-align: center;">
+                <a href="/docs">📚 Documentação Swagger</a> | 
+                <a href="/health">❤️ Health Check</a>
+            </p>
+        </div>
+    </body>
+    </html>
+    """
+
+# ============ Chat Completions (Texto + Visão) ============
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: Request):
+    if not verify_api_key(request):
+        return JSONResponse(status_code=401, content={"error": "Invalid API key"})
+    
+    try:
+        body = await request.json()
+        raw_messages = body.get("messages", [])
+        model = body.get("model", "auto")
+        
+        # Detectar se precisa de visão
+        has_vision = model == "vision" or has_image_content(raw_messages)
+        model_used = "google/gemma-3-27b-it" if has_vision else "LiquidAI/LFM2-8B-A1B"
+        client = vision_client if has_vision else chat_client
+        
+        # Cache (apenas para texto)
+        cache_key = get_cache_key(raw_messages, model_used)
+        if not has_vision:
+            cached = get_cached_response(cache_key)
+            if cached:
+                return cached
+
+        # Processar mensagens de visão
+        if has_vision:
+            last_user_msg = next((msg for msg in reversed(raw_messages) if msg.get("role") == "user"), None)
+            if not last_user_msg:
+                return JSONResponse(status_code=400, content={"error": "No user message"})
+            
+            content = last_user_msg.get("content", [])
+            vision_content = []
+            text_parts = []
+            
+            if isinstance(content, list):
+                for item in content:
+                    if isinstance(item, dict):
+                        if item.get("type") == "text":
+                            text_parts.append(item.get("text", ""))
+                        elif item.get("type") == "image_url":
+                            url = item.get("image_url", {}).get("url", "")
+                            if url:
+                                vision_content.append({"type": "image_url", "image_url": {"url": url}})
+                
+                final_text = " ".join(text_parts) if text_parts else "Analise a imagem."
+                vision_content.append({"type": "text", "text": final_text})
+                messages = [{"role": "user", "content": vision_content}]
+            else:
+                messages = raw_messages
+        else:
+            messages = raw_messages
+
+        # Gerar resposta
+        if has_vision:
+            # Usar Inference API para visão
+            response = vision_client.chat_completion(
+                messages=messages,
+                max_tokens=body.get("max_tokens", 1024),
+                temperature=body.get("temperature", 0.7)
+            )
+            response_content = response.choices[0].message.content
+        else:
+            # Usar modelo local para texto
+            response_content = generate_local_chat(
+                messages=messages,
+                max_tokens=body.get("max_tokens", 1024),
+                temperature=body.get("temperature", 0.7)
+            )
+        
+        result = {
+            "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": model_used,
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": response_content
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+            }
+        }
+        
+        if not has_vision:
+            set_cached_response(cache_key, result)
+        return result
+        
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": str(e), "detail": traceback.format_exc()})
+
+# ============ Embeddings ============
+
+@app.post("/v1/embeddings")
+async def create_embeddings(request: Request):
+    if not verify_api_key(request):
+        return JSONResponse(status_code=401, content={"error": "Invalid API key"})
+    
+    try:
+        body = await request.json()
+        input_text = body.get("input", "")
+        texts = input_text if isinstance(input_text, list) else [input_text]
+        
+        embeddings_data = []
+        for idx, text in enumerate(texts):
+            res = embed_client.feature_extraction(text)
+            embedding = res.tolist() if hasattr(res, 'tolist') else res
+            embeddings_data.append({
+                "object": "embedding",
+                "index": idx,
+                "embedding": embedding
+            })
+        
+        return {
+            "object": "list",
+            "data": embeddings_data,
+            "model": "bge-m3",
+            "usage": {"prompt_tokens": sum(len(t.split()) for t in texts), "total_tokens": sum(len(t.split()) for t in texts)}
+        }
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": str(e), "detail": traceback.format_exc()})
+
+# ============ Classificação Zero-Shot ============
+
+@app.post("/v1/classify")
+async def classify_text(request: Request):
+    if not verify_api_key(request):
+        return JSONResponse(status_code=401, content={"error": "Invalid API key"})
+    
+    try:
+        body = await request.json()
+        text = body.get("text", "")
+        labels = body.get("labels", ["positive", "negative", "neutral"])
+        multi_label = body.get("multi_label", False)
+        
+        if not text:
+            return JSONResponse(status_code=400, content={"error": "Text is required"})
+        
+        # Cache
+        cache_key = get_cache_key(text + str(labels), "classify")
+        cached = get_cached_response(cache_key)
+        if cached:
+            return cached
+        
+        result = classify_client.zero_shot_classification(
+            text,
+            labels,
+            multi_label=multi_label
+        )
+        
+        response = {
+            "object": "classification",
+            "text": text,
+            "labels": result.labels if hasattr(result, 'labels') else labels,
+            "scores": result.scores if hasattr(result, 'scores') else [],
+            "predicted_label": result.labels[0] if hasattr(result, 'labels') and result.labels else None,
+            "model": "bart-large-mnli"
+        }
+        
+        set_cached_response(cache_key, response)
+        return response
+        
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": str(e), "detail": traceback.format_exc()})
+
+# ============ Sumarização ============
+
+@app.post("/v1/summarize")
+async def summarize_text(request: Request):
+    if not verify_api_key(request):
+        return JSONResponse(status_code=401, content={"error": "Invalid API key"})
+    
+    try:
+        body = await request.json()
+        text = body.get("text", "")
+        max_length = body.get("max_length", 150)
+        min_length = body.get("min_length", 30)
+        
+        if not text:
+            return JSONResponse(status_code=400, content={"error": "Text is required"})
+        
+        # Cache
+        cache_key = get_cache_key(text, "summarize")
+        cached = get_cached_response(cache_key)
+        if cached:
+            return cached
+        
+        result = summarize_client.summarization(
+            text,
+            parameters={"max_length": max_length, "min_length": min_length}
+        )
+        
+        summary = result.summary_text if hasattr(result, 'summary_text') else str(result)
+        
+        response = {
+            "object": "summarization",
+            "original_length": len(text),
+            "summary": summary,
+            "summary_length": len(summary),
+            "compression_ratio": round(len(summary) / len(text) * 100, 2),
+            "model": "bart-large-cnn"
+        }
+        
+        set_cached_response(cache_key, response)
+        return response
+        
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": str(e), "detail": traceback.format_exc()})
+
+# ============ Análise de Sentimento ============
+
+@app.post("/v1/sentiment")
+async def analyze_sentiment(request: Request):
+    if not verify_api_key(request):
+        return JSONResponse(status_code=401, content={"error": "Invalid API key"})
+    
+    try:
+        body = await request.json()
+        text = body.get("text", "")
+        
+        if not text:
+            return JSONResponse(status_code=400, content={"error": "Text is required"})
+        
+        # Cache
+        cache_key = get_cache_key(text, "sentiment")
+        cached = get_cached_response(cache_key)
+        if cached:
+            return cached
+        
+        result = sentiment_client.text_classification(text)
+        
+        # Mapear labels para português
+        label_map = {
+            "positive": "positivo",
+            "negative": "negativo",
+            "neutral": "neutro",
+            "POSITIVE": "positivo",
+            "NEGATIVE": "negativo",
+            "NEUTRAL": "neutro"
+        }
+        
+        if isinstance(result, list) and len(result) > 0:
+            top_result = result[0]
+            label = top_result.label if hasattr(top_result, 'label') else str(top_result)
+            score = top_result.score if hasattr(top_result, 'score') else 0.0
+        else:
+            label = str(result)
+            score = 1.0
+        
+        response = {
+            "object": "sentiment",
+            "text": text,
+            "sentiment": label_map.get(label, label),
+            "sentiment_raw": label,
+            "confidence": round(score, 4),
+            "all_scores": [{"label": r.label, "score": round(r.score, 4)} for r in result] if isinstance(result, list) else [],
+            "model": "roberta-sentiment"
+        }
+        
+        set_cached_response(cache_key, response)
+        return response
+        
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": str(e), "detail": traceback.format_exc()})
+
+# ============ Endpoints Auxiliares ============
+
+@app.get("/v1/models")
+async def list_models():
+    return {
+        "object": "list",
+        "data": [
+            {"id": "lfm2-8b", "object": "model", "owned_by": "liquidai", "description": "Chat rápido e versátil"},
+            {"id": "gemma-3-vision", "object": "model", "owned_by": "google", "description": "Análise de imagens"},
+            {"id": "bge-m3", "object": "model", "owned_by": "baai", "description": "Embeddings multilíngue"},
+            {"id": "xlm-roberta-classify", "object": "model", "owned_by": "joeddav", "description": "Classificação zero-shot multilíngue"},
+            {"id": "mt5-summarize", "object": "model", "owned_by": "csebuetnlp", "description": "Sumarização multilíngue (45 idiomas)"},
+            {"id": "distilbert-sentiment", "object": "model", "owned_by": "lxyuan", "description": "Análise de sentimento multilíngue"}
+        ]
+    }
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "cache_size": len(response_cache),
+        "version": "4.0.0",
+        "models": {
+            "chat": "LiquidAI/LFM2-8B-A1B",
+            "vision": "google/gemma-3-27b-it",
+            "embeddings": "BAAI/bge-m3",
+            "classify": "joeddav/xlm-roberta-large-xnli",
+            "summarize": "csebuetnlp/mT5_multilingual_XLSum",
+            "sentiment": "lxyuan/distilbert-base-multilingual-cased-sentiments-student"
+        }
+    }
+
+@app.delete("/v1/cache/clear")
+async def clear_cache(request: Request):
+    if not verify_api_key(request):
+        return JSONResponse(status_code=401, content={"error": "Invalid API key"})
+    global response_cache
+    response_cache = {}
+    return {"message": "Cache cleared", "timestamp": datetime.now().isoformat()}

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+huggingface-hub>=0.25.0
+python-multipart==0.0.6
+torch>=2.0.0
+transformers>=4.40.0
+accelerate>=0.27.0
+sentencepiece