Agentes de IA para E-commerce: Como Construir Sistemas que Vendem, Atendem e Precificam Sozinhos

75% dos donos de e-commerce já usam IA — mas a maioria ainda limita-se a chatbots básicos e recomendações genéricas. A diferença entre quem extrai valor real e quem queima dinheiro está em construir agentes autônomos que conhecem seu catálogo, estoque, preço e comportamento do cliente em tempo real.

Este guia cobre os 5 agentes de IA que mais impactam vendas, atendimento e margem no e-commerce. Ao final de cada seção, você tem arquitetura, código Python funcional, métricas de sucesso e custo estimado. No meu sistema.

Este guia cobre:

• Recomendação personalizada — como triplicar receita com sugestões contextuais
• Chatbot com acesso ao catálogo — atendimento que resolve sem humano
• Pricing dinâmico — ajuste de preços em tempo real baseado em demanda e concorrência
• Recuperação de carrinho abandonado — resgate inteligente com ofertas personalizadas
• Análise de sentimento — extrair insights de reviews automaticamente

Panorama: IA em E-commerce em 2026

Antes de mergulhar nos agentes, entenda o cenário atual:

Nota importante: Estes números representam médias globais. No Brasil, a adoção está crescendo rapidamente, mas ainda há espaço para diferenciação real — especialmente para lojas que implementam agentes além de chatbots básicos.

Os 5 Agentes que Cobriremos

Este guia aborda cinco categorias de agentes de IA para e-commerce, cada um com características, custos e impactos distintos:

Agente 1: Recomendação Personalizada

O problema

Recomendações genéricas ("você também pode gostar de...") convertem pouco. O cliente precisa de sugestões contextuais — baseadas no que ele está vendo agora, no histórico de compras e no comportamento de navegação.

Arquitetura

Pipeline de Dados

O fluxo completo do agente de recomendação envolve 5 etapas sequenciais, desde a coleta de dados do usuário até a entrega de recomendações personalizadas:

Implementação

# recommendation_agent.py
# Agente de recomendação com busca vetorial + LLM re-ranking

from openai import OpenAI
from pinecone import Pinecone
from typing import List, Dict
import json

class RecommendationAgent:
    def __init__(self, openai_key: str, pinecone_key: str, index_name: str):
        self.llm = OpenAI(api_key=openai_key)
        self.pc = Pinecone(api_key=pinecone_key)
        self.index = self.pc.Index(index_name)
    
    def get_user_context(self, user_id: str) -> Dict:
        """Recupera contexto do usuário (carrinho, histórico, navegação)."""
        # Em produção: buscar do seu banco de dados
        return {
            "current_cart": ["notebook-dell-xps", "mouse-logitech"],
            "browse_history": ["monitor-27inch", "teclado-mecanico", "webcam-hd"],
            "purchase_history": ["headset-gamer", "mousepad-xl"],
            "preferences": {"budget": "mid-range", "brand_affinity": ["dell", "logitech"]}
        }
    
    def find_similar_products(self, query: str, top_k: int = 20) -> List[Dict]:
        """Busca vetorial por produtos similares."""
        # Gerar embedding da query
        embedding = self.llm.embeddings.create(
            model="text-embedding-3-large",
            input=query
        ).data[0].embedding
        
        # Buscar no Pinecone
        results = self.index.query(
            vector=embedding,
            top_k=top_k,
            include_metadata=True
        )
        return [match.metadata for match in results.matches]
    
    def rerank_with_context(self, candidates: List[Dict], user_context: Dict) -> List[Dict]:
        """LLM re-ranking baseado no contexto do usuário."""
        prompt = f"""
        Você é um especialista em e-commerce. Re-ranke os produtos candidatos
        baseado no contexto do usuário para maximizar relevância e conversão.
        
        Contexto do usuário:
        - Carrinho atual: {json.dumps(user_context['current_cart'])}
        - Histórico de navegação: {json.dumps(user_context['browse_history'])}
        - Compras anteriores: {json.dumps(user_context['purchase_history'])}
        - Preferências: {json.dumps(user_context['preferences'])}
        
        Candidatos: {json.dumps(candidates[:10])}
        
        Retorne JSON com top 5 produtos, cada um com:
        - product_id
        - relevance_score (0-100)
        - reason (por que é relevante para este usuário)
        """
        
        response = self.llm.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            response_format={"type": "json_object"}
        )
        
        return json.loads(response.choices[0].message.content)["products"]
    
    def recommend(self, user_id: str, context: str = "") -> List[Dict]:
        """Pipeline completo de recomendação."""
        # 1. Buscar contexto do usuário
        user_context = self.get_user_context(user_id)
        
        # 2. Construir query baseada no contexto
        query = f"{context} {' '.join(user_context['browse_history'][:3])}"
        
        # 3. Busca vetorial (fast path)
        candidates = self.find_similar_products(query, top_k=20)
        
        # 4. LLM re-ranking (smart path)
        recommendations = self.rerank_with_context(candidates, user_context)
        
        return recommendations


# Endpoint FastAPI
from fastapi import FastAPI
app = FastAPI()
agent = RecommendationAgent(
    openai_key="sk-...",
    pinecone_key="pc-...",
    index_name="products"
)

@app.get("/recommend/{user_id}")
async def get_recommendations(user_id: str, context: str = ""):
    return {"recommendations": agent.recommend(user_id, context)}

Métricas de sucesso

Custo estimado (100k usuários/mês)

Agente 2: Chatbot com Acesso ao Catálogo

O problema

Chatbots tradicionais não sabem o estoque atual, o prazo de entrega real ou as políticas de troca específicas. Resultado: respostas genéricas que frustram o cliente.

Arquitetura

O agente usa ferramentas (tools) para acessar sistemas reais em tempo real:

# catalog_chatbot.py
# Chatbot com acesso real ao catálogo, estoque e frete

from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# Tools que acessam sistemas reais
@tool
def check_product_stock(sku: str) -> str:
    """Verifica disponibilidade e quantidade em estoque de um produto."""
    # Em produção: conectar ao ERP (Bling, Tiny, VTEX, SAP)
    stock_data = {
        "NOTEBOOK-XPS-15": {"available": 12, "warehouse": "SP", "restock_date": None},
        "MOUSE-MX-MASTER": {"available": 0, "warehouse": "SP", "restock_date": "2026-07-15"},
    }
    data = stock_data.get(sku, {"available": 0, "error": "SKU não encontrado"})
    return json.dumps(data)

@tool
def get_shipping_estimate(zip_code: str, items: list) -> str:
    """Calcula frete e prazo de entrega para um CEP e itens."""
    # Em produção: integração com transportadoras (Correios, Jadlog, Total Express)
    return json.dumps({
        "options": [
            {"carrier": "SEDEX", "price": 45.90, "days": 2},
            {"carrier": "PAC", "price": 25.50, "days": 7},
            {"carrier": "Expresso", "price": 35.00, "days": 3}
        ]
    })

@tool
def get_return_policy(product_category: str) -> str:
    """Retorna política de troca/devolução para uma categoria de produto."""
    policies = {
        "electronics": {"days": 7, "condition": "lacrado ou com defeito", "free_return": True},
        "clothing": {"days": 30, "condition": "com etiqueta, sem uso", "free_return": True},
        "default": {"days": 7, "condition": "sem uso, embalagem original", "free_return": False}
    }
    return json.dumps(policies.get(product_category, policies["default"]))

@tool
def search_products(query: str, filters: dict = None) -> str:
    """Busca produtos no catálogo por texto e filtros."""
    # Em produção: integração com Elasticsearch, Algolia ou busca nativa do e-commerce
    products = [
        {
            "sku": "NOTEBOOK-XPS-15",
            "name": "Dell XPS 15 i7 16GB 512GB SSD",
            "price": 8999.00,
            "category": "electronics",
            "rating": 4.7,
            "reviews_count": 234
        },
        {
            "sku": "MOUSE-MX-MASTER",
            "name": "Logitech MX Master 3S",
            "price": 499.90,
            "category": "electronics",
            "rating": 4.8,
            "reviews_count": 1892
        }
    ]
    return json.dumps(products[:5])

# Construir o agente
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)

prompt = ChatPromptTemplate.from_messages([
    ("system", """Você é um assistente de vendas especializado da loja.
    
    REGRAS:
    - Sempre verifique estoque ANTES de recomendar um produto
    - Ofereça frete e prazo quando o cliente perguntar sobre entrega
    - Se o produto não estiver em estoque, sugira alternativas
    - Seja amigável mas profissional, use linguagem acessível
    - Nunca invente informações — consulte as ferramentas disponíveis
    - Se não souber algo, diga que vai verificar com a equipe"""),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

agent = create_openai_tools_agent(llm, [check_product_stock, get_shipping_estimate, get_return_policy, search_products], prompt)
executor = AgentExecutor(agent=agent, tools=[check_product_stock, get_shipping_estimate, get_return_policy, search_products], verbose=True)

# Exemplo de uso
async def chat(user_message: str, chat_history: list = []):
    result = await executor.ainvoke({
        "input": user_message,
        "chat_history": chat_history
    })
    return result["output"]

Métricas de sucesso

Custo estimado (10k conversas/mês)

Agente 3: Pricing Dinâmico

O problema

Preços estáticos deixam dinheiro na mesa. Quando a demanda sobe ou o concorrente baixa o preço, você perde vendas ou margem.

Estratégias de pricing

Implementação

# dynamic_pricing_agent.py
# Agente de pricing dinâmico multi-estratégia

from dataclasses import dataclass
from typing import Optional
import numpy as np

@dataclass
class PricingDecision:
    product_id: str
    current_price: float
    recommended_price: float
    strategy_used: str
    confidence: float
    reasoning: str

class DynamicPricingAgent:
    def __init__(self, min_margin: float = 0.15):
        self.min_margin = min_margin  # Margem mínima aceitável
    
    def calculate_price(
        self,
        product_id: str,
        cost: float,
        current_price: float,
        competitor_price: Optional[float],
        demand_score: float,  # 0-1, onde 1 = alta demanda
        stock_level: int,
        stock_threshold: int = 10
    ) -> PricingDecision:
        """Calcula preço ótimo combinando múltiplas estratégias."""
        
        prices = []
        
        # Estratégia 1: Cost-Plus (sempre presente como floor)
        min_price = cost * (1 + self.min_margin)
        prices.append(("cost_plus", min_price, 0.3))
        
        # Estratégia 2: Competitor Match
        if competitor_price:
            # Estratégia: ficar 2-5% abaixo do concorrente
            competitor_based = competitor_price * 0.97
            prices.append(("competitor_match", competitor_based, 0.25))
        
        # Estratégia 3: Demand-Based
        if demand_score > 0.7:  # Alta demanda
            demand_multiplier = 1 + (demand_score - 0.5) * 0.3
            demand_price = current_price * demand_multiplier
            prices.append(("demand_based", demand_price, 0.25))
        
        # Estratégia 4: Inventory-Aware
        if stock_level <= stock_threshold:
            scarcity_multiplier = 1 + (1 - stock_level / stock_threshold) * 0.2
            inventory_price = current_price * scarcity_multiplier
            prices.append(("inventory_aware", inventory_price, 0.2))
        
        # Decisão final: média ponderada
        total_weight = sum(w for _, _, w in prices)
        final_price = sum(p * w for _, p, w in prices) / total_weight
        
        # Garantir margem mínima
        final_price = max(final_price, min_price)
        
        # Arredondar para .90 ou .99 (psicológico)
        final_price = self._psychological_round(final_price)
        
        # Determinar estratégia dominante
        dominant = max(prices, key=lambda x: x[2])
        
        return PricingDecision(
            product_id=product_id,
            current_price=current_price,
            recommended_price=final_price,
            strategy_used=dominant[0],
            confidence=0.85,
            reasoning=f"Estratégia dominante: {dominant[0]}. "
                     f"Demanda: {demand_score:.2f}, Estoque: {stock_level} unidades."
        )
    
    def _psychological_round(self, price: float) -> float:
        """Arredonda para preço psicológico (.90 ou .99)."""
        if price < 50:
            return round(price) - 0.10  # Ex: 29.90
        elif price < 200:
            return round(price, -1) - 0.10  # Ex: 149.90
        else:
            return round(price, -2) + 99.90  # Ex: 899.90


# Exemplo de uso
agent = DynamicPricingAgent(min_margin=0.15)

decision = agent.calculate_price(
    product_id="NOTEBOOK-XPS-15",
    cost=5500.00,
    current_price=8999.00,
    competitor_price=8499.00,
    demand_score=0.82,  # Alta demanda
    stock_level=8,  # Estoque baixo
    stock_threshold=10
)

print(f"Preço recomendado: R$ {decision.recommended_price:.2f}")
print(f"Estratégia: {decision.strategy_used}")
print(f"Justificativa: {decision.reasoning}")

Métricas de sucesso

Custo estimado (10k SKUs)

Agente 4: Recuperação de Carrinho Abandonado

O problema

A taxa média de abandono de carrinho é de 70%. A maioria das lojas envia emails genéricos que são ignorados.

Segmentação de abandono

Implementação

# cart_recovery_agent.py
# Agente de recuperação de carrinho abandonado

from datetime import datetime, timedelta
from typing import List, Dict
import json

class CartRecoveryAgent:
    def __init__(self, llm_client):
        self.llm = llm_client
        self.recovery_windows = {
            "price_sensitive": {"hours": 2, "discount": 0.12},
            "browsing": {"hours": 4, "discount": 0},
            "forgot": {"hours": 1, "discount": 0},
            "competitor_switch": {"hours": 24, "discount": 0.10},
            "checkout_friction": {"hours": 0.5, "discount": 0.05},
        }
    
    def segment_abandonment(self, cart_data: Dict, user_history: Dict) -> str:
        """Classifica o tipo de abandono usando LLM."""
        prompt = f"""
        Analise este abandono de carrinho e classifique em um segmento:
        
        Carrinho: {json.dumps(cart_data)}
        Histórico do usuário: {json.dumps(user_history)}
        
        Segmentos possíveis:
        - price_sensitive: usuário busca descontos, comparou preços
        - browsing: usuário navega muito, baixa taxa de conversão
        - forgot: usuário é fiel, carrinho alto, pode ter esquecido
        - competitor_switch: usuário pesquisou concorrentes
        - checkout_friction: usuário tentou finalizar mas desistiu
        
        Retorne APENAS o nome do segmento.
        """
        
        response = self.llm.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.1
        )
        
        return response.choices[0].message.content.strip()
    
    def generate_recovery_message(
        self,
        segment: str,
        user_name: str,
        cart_items: List[Dict],
        discount_percent: float = 0
    ) -> Dict[str, str]:
        """Gera mensagem personalizada de recuperação."""
        
        items_text = "\n".join([
            f"- {item['name']} (R$ {item['price']:.2f})"
            for item in cart_items[:3]
        ])
        
        prompt = f"""
        Crie uma mensagem de recuperação de carrinho abandonado.
        
        Segmento: {segment}
        Nome: {user_name}
        Itens: {items_text}
        Desconto disponível: {discount_percent * 100 if discount_percent > 0 else 'nenhum'}%
        
        Regras:
        - Tom amigável, não agressivo
        - Máximo 3 parágrafos curtos
        - Se houver desconto, mencione naturalmente (não force)
        - Inclua call-to-action claro
        - Para WhatsApp: máximo 500 caracteres
        """
        
        response = self.llm.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.7
        )
        
        return {
            "email_subject": f"Esqueceu algo, {user_name}?",
            "email_body": response.choices[0].message.content,
            "whatsapp": response.choices[0].message.content[:500],
            "push_notification": f"Seu carrinho está te esperando! {len(cart_items)} itens reservados."
        }
    
    def create_recovery_campaign(
        self,
        cart_id: str,
        user_data: Dict,
        cart_data: Dict
    ) -> Dict:
        """Cria campanha completa de recuperação."""
        
        # 1. Segmentar o abandono
        segment = self.segment_abandonment(cart_data, user_data.get("history", {}))
        
        # 2. Definir estratégia
        strategy = self.recovery_windows.get(segment, self.recovery_windows["forgot"])
        
        # 3. Gerar mensagens
        messages = self.generate_recovery_message(
            segment=segment,
            user_name=user_data.get("name", "Cliente"),
            cart_items=cart_data.get("items", []),
            discount_percent=strategy["discount"]
        )
        
        # 4. Definir timing
        recovery_time = datetime.now() + timedelta(hours=strategy["hours"])
        
        return {
            "cart_id": cart_id,
            "segment": segment,
            "strategy": strategy,
            "messages": messages,
            "schedule": {
                "first_contact": recovery_time.isoformat(),
                "follow_up": (recovery_time + timedelta(hours=24)).isoformat(),
                "final_attempt": (recovery_time + timedelta(days=3)).isoformat()
            },
            "discount_code": f"VOLTE10" if strategy["discount"] > 0 else None
        }


# Exemplo de uso
agent = CartRecoveryAgent(llm_client=openai_client)

campaign = agent.create_recovery_campaign(
    cart_id="CART-12345",
    user_data={
        "name": "Maria",
        "email": "maria@email.com",
        "history": {"purchases": 5, "avg_ticket": 350, "last_purchase_days": 15}
    },
    cart_data={
        "items": [
            {"name": "Vestido Floral", "price": 189.90},
            {"name": "Sandália Couro", "price": 259.90}
        ],
        "total": 449.80,
        "abandoned_at": "2026-06-29T14:30:00"
    }
)

Métricas de sucesso

Custo estimado (5k carrinhos abandonados/mês)

Agente 5: Análise de Sentimento e Reviews

O problema

Milhares de reviews são escritos todo mês, mas a maioria das lojas não extrai insights acionáveis deles.

Implementação

# sentiment_agent.py
# Agente de análise de sentimento e extração de insights

from typing import List, Dict
from collections import Counter
import json

class SentimentAgent:
    def __init__(self, llm_client):
        self.llm = llm_client
    
    def analyze_review(self, review_text: str, product_name: str) -> Dict:
        """Analisa uma review individual."""
        prompt = f"""
        Analise esta review de produto e extraia:
        
        Review: "{review_text}"
        Produto: {product_name}
        
        Retorne JSON com:
        - sentiment: "positive", "negative", "neutral"
        - score: -1.0 a 1.0
        - aspects: lista de aspectos mencionados (qualidade, preço, entrega, etc.)
        - pain_points: lista de problemas mencionados
        - highlights: lista de pontos positivos
        - action_needed: true se precisa resposta/ação da equipe
        - suggested_response: sugestão de resposta se action_needed for true
        """
        
        response = self.llm.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            response_format={"type": "json_object"}
        )
        
        return json.loads(response.choices[0].message.content)
    
    def generate_insights_report(self, reviews: List[Dict]) -> Dict:
        """Gera relatório consolidado de insights."""
        
        # Estatísticas básicas
        sentiments = Counter([r["sentiment"] for r in reviews])
        total = len(reviews)
        
        # Extrair pain points mais comuns
        all_pain_points = []
        for r in reviews:
            all_pain_points.extend(r.get("pain_points", []))
        top_pain_points = Counter(all_pain_points).most_common(5)
        
        # Extrair highlights mais comuns
        all_highlights = []
        for r in reviews:
            all_highlights.extend(r.get("highlights", []))
        top_highlights = Counter(all_highlights).most_common(5)
        
        # Gerar recomendações com LLM
        prompt = f"""
        Com base nestes dados de reviews, gere 3-5 recomendações acionáveis:
        
        Sentimento geral:
        - Positivo: {sentiments.get('positive', 0)} ({sentiments.get('positive', 0)/total*100:.1f}%)
        - Negativo: {sentiments.get('negative', 0)} ({sentiments.get('negative', 0)/total*100:.1f}%)
        - Neutro: {sentiments.get('neutral', 0)} ({sentiments.get('neutral', 0)/total*100:.1f}%)
        
        Top problemas: {json.dumps(top_pain_points)}
        Top pontos positivos: {json.dumps(top_highlights)}
        
        Retorne recomendações específicas e acionáveis.
        """
        
        response = self.llm.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}]
        )
        
        return {
            "summary": {
                "total_reviews": total,
                "avg_score": sum(r["score"] for r in reviews) / total,
                "sentiment_distribution": dict(sentiments)
            },
            "top_pain_points": top_pain_points,
            "top_highlights": top_highlights,
            "recommendations": response.choices[0].message.content,
            "reviews_needing_response": [r for r in reviews if r.get("action_needed")]
        }


# Exemplo de uso
agent = SentimentAgent(llm_client=openai_client)

# Analisar reviews de um produto
reviews_raw = [
    "Produto excelente! Chegou antes do prazo e a qualidade é incrível.",
    "Gostei do produto, mas a embalagem chegou danificada.",
    "Não recomendo. O produto parou de funcionar após 2 semanas.",
]

analyses = [agent.analyze_review(r, "Fone Bluetooth XYZ") for r in analyses]
report = agent.generate_insights_report(analyses)

Métricas de sucesso

Custo estimado (10k reviews/mês)

Custos Consolidados

Dica: Comece com 1 agente (recomendação ou chatbot), meça resultados por 90 dias, e só então escale para os próximos. A maioria das lojas vê ROI positivo com apenas o agente de recomendação.

Decisão: Qual Agente Implementar Primeiro?

A escolha do primeiro agente depende do seu perfil de negócio, orçamento e maturidade técnica:

Quando NÃO Usar Agentes de IA

Antes de investir, avalie se faz sentido:

Stack Tecnológico Recomendado

Para quem está começando:

Próximos Passos

1. Escolha 1 agente para começar (recomendação é o mais seguro)
2. Defina métricas baseline antes de implementar
3. Implemente MVP em 2-4 semanas
4. Meça por 90 dias com testes A/B
5. Escale apenas se houver ROI positivo

Leia também:

• ACP na Prática — Quando agentes compram e vendem
• Pipeline Multi-Agente — Como usar múltiplos agentes
• MCP para Não-Programadores — Conecte IA a qualquer ferramenta

Publicado em andrecosta.ia.br.