0Pricing
AI Agents · Aula

Gerenciamento do contexto e do histórico do cliente

Respostas personalizadas com base em compras anteriores, tickets e preferências.

Gerenciamento do contexto e do histórico do cliente é uma aula grátis de AI Agents no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Agents, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Agents inclui 4 aulas no total.

Por que o contexto faz os agentes parecerem humanos

A diferença entre um agente de atendimento ao cliente medíocre e um excelente é o contexto. Quando um agente diz "Vejo que sua assinatura será renovada na próxima semana — gostaria de pausá-la antes disso?", o cliente se sente reconhecido, e não apenas processado.

Esta lição aborda como criar uma camada completa de contexto do cliente para seus agentes.

Esquema do perfil do cliente

Defina um perfil de cliente padrão que agregue dados de várias fontes. O agente recebe esse dicionário no início de cada conversa.

from dataclasses import dataclass, field
from datetime import date

@dataclass
class CustomerProfile:
    customer_id: str
    name: str
    email: str
    join_date: date
    subscription_tier: str          # 'free', 'pro', 'enterprise'
    account_age_days: int
    lifetime_value_usd: float
    previous_tickets: list[dict] = field(default_factory=list)
    recent_purchases: list[dict]  = field(default_factory=list)
    preferences: dict             = field(default_factory=dict)

    @property
    def is_long_term_customer(self) -> bool:
        return self.account_age_days > 365

if __name__ == '__main__':
    from datetime import date
    profile = CustomerProfile(
        customer_id='cust_1', name='Jane Doe', email='jane@example.com',
        join_date=date(2023, 1, 15), subscription_tier='pro',
        account_age_days=400, lifetime_value_usd=1250.50,
    )
    print(f'{profile.name} ({profile.subscription_tier}) - long-term customer: {profile.is_long_term_customer}')

Obtenção do histórico de compras

Obtenha os últimos N pedidos do sistema de comércio eletrônico. Inclua a data do pedido, os itens, o total e a situação. Isso informa ao agente o que o cliente comprou e se algum pedido recente apresenta problemas.

import requests

SHOP_API = 'https://api.yourshop.com'
SHOP_KEY  = 'YOUR_SHOP_API_KEY'

def get_purchase_history(customer_id: str, limit: int = 10) -> list[dict]:
    resp = requests.get(
        f'{SHOP_API}/customers/{customer_id}/orders',
        headers={'Authorization': f'Bearer {SHOP_KEY}'},
        params={'limit': limit, 'sort': '-created_at'}
    )
    resp.raise_for_status()
    orders = resp.json()['orders']
    return [
        {
            'order_id':   o['id'],
            'date':       o['created_at'][:10],
            'total_usd':  o['total'],
            'status':     o['status'],
            'items':      [i['name'] for i in o['line_items']]
        }
        for o in orders
    ]

Obtenção de chamados de suporte anteriores

Obtenha os últimos N chamados de suporte para entender problemas recorrentes. Se o mesmo problema do cliente já tiver sido resolvido três vezes, isso indica um problema no produto — encaminhe o caso para a equipe responsável e sinalize-o adequadamente.

def get_support_history(customer_id: str, limit: int = 5) -> list[dict]:
    resp = requests.get(
        f'{SHOP_API}/customers/{customer_id}/tickets',
        headers={'Authorization': f'Bearer {SHOP_KEY}'},
        params={'limit': limit, 'sort': '-created_at'}
    )
    resp.raise_for_status()
    tickets = resp.json()['tickets']
    return [
        {
            'ticket_id': t['id'],
            'subject':   t['subject'],
            'status':    t['status'],
            'resolved':  t.get('resolved_at', ''),
            'category':  t.get('category', 'general')
        }
        for t in tickets
    ]

def has_recurring_issue(tickets: list[dict], category: str) -> bool:
    return sum(1 for t in tickets if t['category'] == category) >= 3

Leitura do nível e da situação da assinatura

O nível da assinatura determina a que o cliente tem direito. Um cliente do plano Pro que pergunta sobre um recurso indisponível em seu plano precisa de uma resposta diferente da de um cliente do plano Enterprise com a mesma pergunta.

def get_subscription_info(customer_id: str) -> dict:
    resp = requests.get(
        f'{SHOP_API}/customers/{customer_id}/subscription',
        headers={'Authorization': f'Bearer {SHOP_KEY}'}
    )
    if resp.status_code == 404:
        return {'tier': 'free', 'status': 'active', 'renewal_date': None}
    resp.raise_for_status()
    sub = resp.json()
    return {
        'tier':         sub['plan'],
        'status':       sub['status'],        # active / past_due / canceled
        'renewal_date': sub.get('current_period_end', '')[:10],
        'cancel_at':    sub.get('cancel_at_period_end', False)
    }

Calculando o tempo de existência da conta

O tempo de existência da conta indica a fidelidade do cliente. Um cliente que está com você desde 2021 deve ser tratado de maneira diferente de alguém que se cadastrou ontem. Mencione o tempo de relacionamento quando apropriado para criar proximidade.

from datetime import datetime, timezone

def calculate_account_age(join_date_str: str) -> dict:
    join = datetime.fromisoformat(join_date_str.replace('Z', '+00:00'))
    now  = datetime.now(timezone.utc)
    delta = now - join
    years  = delta.days // 365
    months = (delta.days % 365) // 30
    return {
        'days':   delta.days,
        'years':  years,
        'months': months,
        'label':  f'{years} year(s) and {months} month(s)' if years else f'{months} month(s)'
    }

age = calculate_account_age('2021-03-15T00:00:00Z')
print(age['label'])  # e.g. '5 year(s) and 2 month(s)'

Construindo o texto de contexto para o LLM

Converta o perfil do cliente em um bloco de contexto conciso, inserido no prompt do sistema. Mantenha-o curto — inclua apenas fatos diretamente relevantes para a sessão atual.

def build_context_block(profile: CustomerProfile) -> str:
    recent_order = profile.recent_purchases[0] if profile.recent_purchases else None
    last_ticket  = profile.previous_tickets[0]  if profile.previous_tickets  else None
    parts = [
        f'Customer: {profile.name} ({profile.email})',
        f'Account age: {profile.account_age_days} days | Tier: {profile.subscription_tier}',
        f'Lifetime value: USD {profile.lifetime_value_usd:.0f}',
    ]
    if recent_order:
        parts.append(
            f'Last order: {recent_order["date"]} — '
            f'{', '.join(recent_order["items"][:2])} ({recent_order["status"]})'
        )
    if last_ticket:
        parts.append(f'Last ticket: "{last_ticket["subject"]}" ({last_ticket["status"]})')
    return '\n'.join(parts)

Personalizando respostas com contexto

Insira o bloco de contexto no prompt do sistema para que o LLM faça referência a ele naturalmente nas respostas, sem receber instruções explícitas para isso.

import openai

client = openai.OpenAI(api_key='YOUR_OPENAI_KEY')

def respond_with_context(user_message: str, profile: CustomerProfile) -> str:
    context = build_context_block(profile)
    system_prompt = (
        f'You are a helpful customer service agent for ShopCo.\n'
        f'Customer context:\n{context}\n\n'
        f'Be warm and personal. Reference their history when relevant. '
        f'Address the customer by first name.'
    )
    resp = client.chat.completions.create(
        model='gpt-4o',
        messages=[
            {'role': 'system', 'content': system_prompt},
            {'role': 'user',   'content': user_message}
        ]
    )
    return resp.choices[0].message.content

Armazenando em cache o contexto do cliente

Buscar dados do perfil em várias APIs a cada mensagem é lento e caro. Armazene o perfil em cache no início da conversa e atualize apenas os campos que podem mudar (situação do pedido, situação do chamado).

import time

profile_cache: dict[str, dict] = {}  # customer_id -> {profile, fetched_at}
CACHE_TTL = 300  # 5 minutes

def get_cached_profile(customer_id: str) -> CustomerProfile | None:
    entry = profile_cache.get(customer_id)
    if entry and time.time() - entry['fetched_at'] < CACHE_TTL:
        return entry['profile']
    return None

def set_cached_profile(customer_id: str, profile: CustomerProfile):
    profile_cache[customer_id] = {
        'profile': profile,
        'fetched_at': time.time()
    }

Detectando situações sensíveis a partir do histórico

O histórico pode revelar padrões que exigem um tratamento especial: um cliente cujos últimos três pedidos apresentaram defeitos, alguém que ameaçou cancelar no mês passado ou um usuário que está com você há 7 anos.

def assess_risk_flags(profile: CustomerProfile) -> list[str]:
    flags = []

    # Check for cancellation risk
    cancel_keywords = ['cancel', 'unsubscribe', 'quit', 'competitor']
    for ticket in profile.previous_tickets:
        if any(kw in ticket.get('subject', '').lower() for kw in cancel_keywords):
            flags.append('cancellation_risk')
            break

    # Defective product pattern
    defective = sum(1 for o in profile.recent_purchases if o.get('status') == 'refunded')
    if defective >= 2:
        flags.append('product_quality_issue')

    # High-value customer
    if profile.lifetime_value_usd > 5000:
        flags.append('high_value_customer')

    return flags

Fluxo completo de montagem do contexto

Combine todas as fontes de dados em uma única função assemble_context(), chamada uma vez no início da conversa.

from datetime import date

def assemble_context(email: str) -> CustomerProfile:
    # Try cache first
    # In production: look up customer_id from email in your user DB
    customer_id = 'CUST_123'

    cached = get_cached_profile(customer_id)
    if cached:
        return cached

    # Fetch from all sources
    sub    = get_subscription_info(customer_id)
    orders = get_purchase_history(customer_id)
    tickets = get_support_history(customer_id)

    profile = CustomerProfile(
        customer_id=customer_id,
        name='Alice Smith',
        email=email,
        join_date=date(2021, 3, 15),
        subscription_tier=sub['tier'],
        account_age_days=calculate_account_age('2021-03-15T00:00:00Z')['days'],
        lifetime_value_usd=1240.00,
        previous_tickets=tickets,
        recent_purchases=orders
    )
    set_cached_profile(customer_id, profile)
    return profile

Qual parte do contexto do cliente permite mais diretamente que o agente diga 'Vejo que você está conosco desde 2021'?

Personalizar respostas exige fazer referência a pontos de dados específicos do perfil do cliente. Identificar qual campo permite fazer essa afirmação é uma questão prática de recuperação de informações.

Recapitulação do contexto do cliente

Um excelente agente de atendimento ao cliente cria um perfil detalhado a partir do histórico de compras, dos chamados de suporte, do nível da assinatura e do tempo de existência da conta. Insira um bloco de contexto conciso no prompt do sistema, armazene-o em cache durante a sessão e use sinalizadores de risco para detectar situações sensíveis antes que elas se agravem.

Perguntas Frequentes

A aula “Gerenciamento do contexto e do histórico do cliente” é grátis?

Sim — o texto completo de “Gerenciamento do contexto e do histórico do cliente” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Agents, atualize para CoddyKit PRO. O curso de AI Agents inclui 4 aulas no total.

O que vou aprender em “Gerenciamento do contexto e do histórico do cliente”?

Respostas personalizadas com base em compras anteriores, tickets e preferências. Você pratica AI Agents com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Agents?

Nenhuma experiência prévia é necessária. AI Agents no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Gerenciamento do contexto e do histórico do cliente”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Agents?

Sim. Cada aula de AI Agents inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Roteamento de tickets e lógica de escalonamento
  2. Integração com CRM: Salesforce e HubSpot
  3. Protocolos de transferência para atendimento humano
  4. Gerenciamento do contexto e do histórico do cliente
← Voltar para AI Agents