Em plataformas de e-commerce, consultas frequentes dos clientes incluem imagens de produtos, como "Qual é o material desta camiseta?" ou "Onde está a data de validade nesta embalagem?". Sistemas tradicionais muitas vezes requerem múltiplas interações ou falham em responder, prejudicando a experiência do usuário. Para resolver isso, vamos implementar um sistema inteligente que utiliza o modelo Llama-3.2V-11B-cot, capaz de analisar imagens e realizar raciocínio lógico para fornecer respostas detalhadas.

Entendendo o Modelo Llama-3.2V-11B-cot

O Llama-3.2V-11B-cot é um modelo de linguagem visual que combina reconhecimento de imagens com raciocínio passo a passo. Seu processo de análise segue uma estrutura clara:

1. RESUMO (SUMMARY): Observação inicial da imagem.
2. DESCRIÇÃO (CAPTION): Descrição detalhada dos elementos-chave.
3. RAIOCÍNIO (REASONING): Análise lógica com base no conteúdo visual.
4. CONCLUSÃO (CONCLUSION): Resposta final integrada.

Por exemplo, se um cliente enviar uma captura de tela com erros de software, o modelo não dirá apenas "é uma imagem de tela". Em vez disso, ele poderia raciocinar que os erros indicam uma exceção de tempo de execução, sugerindo verificar o código-fonte. Isso o torna ideal para atendimento ao cliente, onde respostas precisas são cruciais.

Ambiente e Configuração Inicial

Para implantar o modelo, é necessário um servidor com capacidade adequada. O processo de inicialização é simples e envolve executar um script Python para carregar o modelo.

python /root/Llama-3.2V-11B-cot/app.py

Após a execução, aguarde até que o serviço esteja disponível na porta local 7860, acessível via navegador em http://localhost:7860. A interface permite fazer upload de imagens e realizar consultas para validar o funcionamento.

Desenvolvimento do Sistema de Atendimento

Para integrar o modelo em um sistema real, precisamos de uma API que receba imagens e consultas, e retorne respostas estruturadas. Vamos criar um backend usando FastAPI.

# sistema_atendimento_api.py
import base64
from io import BytesIO
from typing import Optional
import requests
from PIL import Image
from fastapi import FastAPI, File, Form, HTTPException, UploadFile
from fastapi.responses import JSONResponse
from pydantic import BaseModel

# Configuração da aplicação FastAPI
aplicativo = FastAPI(title="API de Atendimento Inteligente", version="1.0")

# URL do serviço do modelo visual
URL_SERVICO_MODELO = "http://127.0.0.1:7860"
ENDPOINT_CONSULTA = f"{URL_SERVICO_MODELO}/api/chat"

class ConsultaCliente(BaseModel):
    pergunta: str
    id_sessao: Optional[str] = None

def converter_imagem_para_base64(imagem: Image.Image) -> str:
    """Converte uma imagem PIL para uma string Base64."""
    buffer = BytesIO()
    imagem.save(buffer, format="JPEG", quality=80)
    return base64.b64encode(buffer.getvalue()).decode()

def chamar_modelo_visual(imagem_b64: str, pergunta: str) -> dict:
    """Envia a imagem e a pergunta ao modelo visual."""
    carga = {
        "image": f"data:image/jpeg;base64,{imagem_b64}",
        "question": pergunta
    }
    try:
        resposta = requests.post(ENDPOINT_CONSULTA, json=carga, timeout=60)
        resposta.raise_for_status()
        return resposta.json()
    except requests.exceptions.RequestException as e:
        raise HTTPException(status_code=503, detail=f"Erro ao acessar o modelo: {e}")

@aplicativo.post("/api/v1/consulta-com-imagem")
async def processar_consulta(
    imagem: UploadFile = File(...),
    pergunta: str = Form(...),
    id_sessao: Optional[str] = Form(None)
):
    """Endpoint principal para consultas com imagem."""
    if not imagem.content_type.startswith('image/'):
        raise HTTPException(status_code=400, detail="Arquivo deve ser uma imagem")
    
    try:
        dados_imagem = await imagem.read()
        imagem_pil = Image.open(BytesIO(dados_imagem))
        imagem_b64 = converter_imagem_para_base64(imagem_pil)
    except Exception as e:
        raise HTTPException(status_code=400, detail=f"Falha no processamento da imagem: {e}")
    
    try:
        resposta_modelo = chamar_modelo_visual(imagem_b64, pergunta)
    except HTTPException as e:
        raise e
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Erro na inferência: {e}")
    
    texto_resposta = resposta_modelo.get("response", "")
    conclusao = "Conclusão não disponível"
    if "CONCLUSION:" in texto_resposta:
        partes = texto_resposta.split("CONCLUSION:")
        if len(partes) > 1:
            conclusao = partes[1].strip()
    
    resultado = {
        "sucesso": True,
        "id_sessao": id_sessao or "nova_sessao",
        "consulta": pergunta,
        "cadeia_raciocinio": texto_resposta,
        "resposta_cliente": conclusao
    }
    return JSONResponse(content=resultado)

@aplicativo.get("/saude")
async def verificar_saude():
    """Endpoint para monitorar o status do serviço."""
    try:
        resp = requests.get(URL_SERVICO_MODELO, timeout=5)
        status_modelo = "ativo" if resp.status_code < 500 else "inativo"
    except:
        status_modelo = "inativo"
    return {"status": "saudavel", "servico_modelo": status_modelo}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(aplicativo, host="0.0.0.0", port=8080)

Testando a API

Com o serviço em execução, teste-o usando ferramentas como curl:

curl -X POST "http://localhost:8080/api/v1/consulta-com-imagem" \
  -F "imagem=@/caminho/para/imagem.jpg" \
  -F "pergunta=Onde está a informação de garantia neste produto?" \
  -F "id_sessao=cliente_987"

A resposta JSON incluirá a cadeia de raciocínio completa e a conclusão extraída para o cliente.

Aprimoramentos para Uso Empresarial

Para tornar o sistema robusto, considere adicionar:

• Memória de Sessão: Gerenciar histórico de conversas usando armazenamento como Redis, permitindo múltiplas interações.
• Integração com Base de Conhecimento: Implementar Recuperação Aumentada por Geração (RAG) para enriquecer respostas com informações de produtos e FAQs internas.
• Processamento Assíncrono: Utilizar filas de tarefas (ex: Celery) para lidar com alto volume de consultas sem bloquear a API.
• Monitoramento e Degraução: Registrar métricas de desempenho e preparar estratégias de fallback, como responder apenas com texto se o modelo visual falhar.

Este sistema pode ser adaptado para diversas aplicações além de atendimento ao cliente, como suporte técnico interno ou análise de imagens de qualidade.