Como Treinar IA com Dados da Sua Empresa: Guia Pratico

Ter um chatbot que responde “nao sei” pra tudo e frustrante. Este guia mostra como alimentar sua IA com conhecimento especifico do seu negocio.

As 3 Abordagens Para Treinar IA

Existem tres formas principais de customizar uma IA:

Abordagem	Complexidade	Custo	Quando Usar
Prompt Engineering	Baixa	Baixo	FAQ simples, poucos dados
RAG (Retrieval)	Media	Medio	Muitos documentos, atualizacao frequente
Fine-tuning	Alta	Alto	Comportamento muito especifico

1. Prompt Engineering: O Basico

A forma mais simples de dar contexto pra IA.

System Prompt Estruturado

const systemPrompt = `Voce e o assistente virtual da Loja XYZ.

INFORMACOES DA EMPRESA:
- Horario: Segunda a Sexta 9h-18h, Sabado 9h-13h
- Endereco: Rua das Flores, 123 - Centro
- WhatsApp: (11) 99999-9999
- Email: contato@lojaxyz.com.br

PRODUTOS PRINCIPAIS:
1. Produto A - R$ 299,00 - Descricao breve
2. Produto B - R$ 499,00 - Descricao breve
3. Produto C - R$ 199,00 - Descricao breve

POLITICAS:
- Troca em ate 7 dias
- Frete gratis acima de R$ 200
- Parcelamento em ate 12x

INSTRUCOES:
- Seja cordial e objetivo
- Se nao souber algo, diga que vai verificar
- Para orcamentos complexos, peca contato do cliente
- Nunca invente informacoes

Responda sempre em portugues brasileiro.`;

Limitacoes

• Context window limitado (4k-128k tokens)
• Informacoes precisam caber no prompt
• Atualizacoes exigem mudanca no codigo

Use quando: Menos de 5 paginas de informacao.

2. RAG: Retrieval Augmented Generation

RAG busca informacoes relevantes em tempo real e injeta no prompt.

Como Funciona

1. Usuario pergunta: "Qual a garantia do produto X?"
2. Sistema busca documentos relevantes sobre garantia
3. Documentos encontrados sao adicionados ao prompt
4. IA responde com base nos documentos

Implementacao Passo a Passo

2.1 Preparar Documentos

Reuna todo conhecimento:

• FAQs
• Politicas
• Catalogos
• Manuais
• Historico de atendimento

Estrutura recomendada:

knowledge/
├── faq.md
├── produtos/
│   ├── produto-a.md
│   ├── produto-b.md
├── politicas/
│   ├── troca.md
│   ├── garantia.md
│   ├── frete.md
└── processos/
    ├── como-comprar.md
    └── como-devolver.md

2.2 Dividir em Chunks

Documentos grandes precisam ser divididos:

function splitIntoChunks(text, chunkSize = 500, overlap = 50) {
  const chunks = [];
  let start = 0;

  while (start < text.length) {
    let end = start + chunkSize;

    // Nao cortar no meio de frase
    if (end < text.length) {
      const lastPeriod = text.lastIndexOf('.', end);
      if (lastPeriod > start + chunkSize * 0.5) {
        end = lastPeriod + 1;
      }
    }

    chunks.push({
      text: text.slice(start, end).trim(),
      start: start,
      end: end
    });

    start = end - overlap;
  }

  return chunks;
}

2.3 Criar Embeddings

Embeddings sao representacoes numericas do texto que permitem busca semantica.

Com OpenAI:

const { OpenAI } = require('openai');
const openai = new OpenAI();

async function createEmbedding(text) {
  const response = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: text
  });

  return response.data[0].embedding;
}

// Processar todos os chunks
async function processDocuments(chunks) {
  const documents = [];

  for (const chunk of chunks) {
    const embedding = await createEmbedding(chunk.text);
    documents.push({
      text: chunk.text,
      embedding: embedding,
      metadata: chunk.metadata
    });
  }

  return documents;
}

Com modelo local (sentence-transformers):

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('neuralmind/bert-base-portuguese-cased')

def create_embeddings(texts):
    return model.encode(texts, convert_to_numpy=True)

2.4 Armazenar em Banco Vetorial

Opcoes:

• Pinecone (cloud, facil)
• Chroma (local, gratis)
• Weaviate (self-hosted)
• pgvector (PostgreSQL)

Exemplo com Chroma:

const { ChromaClient } = require('chromadb');

const client = new ChromaClient();
const collection = await client.createCollection({ name: 'knowledge' });

// Adicionar documentos
await collection.add({
  ids: documents.map((_, i) => `doc_${i}`),
  embeddings: documents.map(d => d.embedding),
  documents: documents.map(d => d.text),
  metadatas: documents.map(d => d.metadata)
});

// Buscar
async function search(query, nResults = 3) {
  const queryEmbedding = await createEmbedding(query);

  const results = await collection.query({
    queryEmbeddings: [queryEmbedding],
    nResults: nResults
  });

  return results.documents[0];
}

2.5 Integrar com Chat

async function chat(userMessage, conversationHistory) {
  // 1. Buscar contexto relevante
  const relevantDocs = await search(userMessage, 3);

  // 2. Construir prompt com contexto
  const contextPrompt = `
Use as informacoes abaixo para responder a pergunta do usuario.
Se a resposta nao estiver nas informacoes, diga que nao tem essa informacao.

INFORMACOES:
${relevantDocs.join('\n\n---\n\n')}

PERGUNTA: ${userMessage}
`;

  // 3. Chamar IA
  const response = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      { role: 'system', content: systemPrompt },
      ...conversationHistory,
      { role: 'user', content: contextPrompt }
    ]
  });

  return response.choices[0].message.content;
}

RAG Avancado

Busca Hibrida (Keyword + Semantica)

async function hybridSearch(query, nResults = 5) {
  // Busca semantica
  const semanticResults = await semanticSearch(query, nResults);

  // Busca por keyword (BM25)
  const keywordResults = await keywordSearch(query, nResults);

  // Combinar e ranquear
  const combined = mergeResults(semanticResults, keywordResults);

  return combined.slice(0, nResults);
}

Re-ranking

const { CohereClient } = require('cohere-ai');
const cohere = new CohereClient();

async function rerankResults(query, documents) {
  const response = await cohere.rerank({
    query: query,
    documents: documents,
    model: 'rerank-multilingual-v2.0'
  });

  return response.results
    .sort((a, b) => b.relevanceScore - a.relevanceScore)
    .map(r => documents[r.index]);
}

3. Fine-tuning: Treinamento Customizado

Fine-tuning ajusta os pesos do modelo para comportamento especifico.

Quando Usar

• Precisa de tom de voz muito especifico
• Respostas precisam seguir formato exato
• Tarefas muito especializadas
• RAG nao esta dando bons resultados

Preparar Dados

Formato JSONL para OpenAI:

{"messages": [{"role": "system", "content": "Assistente da Loja XYZ"}, {"role": "user", "content": "Qual o horario de funcionamento?"}, {"role": "assistant", "content": "Funcionamos de segunda a sexta das 9h as 18h, e sabado das 9h as 13h."}]}
{"messages": [{"role": "system", "content": "Assistente da Loja XYZ"}, {"role": "user", "content": "Voces entregam?"}, {"role": "assistant", "content": "Sim! Entregamos em todo o Brasil. Frete gratis para compras acima de R$ 200."}]}

Quantidade de Exemplos

Objetivo	Minimo	Recomendado
Tom de voz	50	200+
Formato de resposta	100	500+
Conhecimento especifico	500	1000+

Criar Dataset de Conversas

import json

def create_training_data(conversations):
    """
    conversations = [
        {
            'pergunta': 'Qual o preco?',
            'resposta': 'O produto X custa R$ 299.'
        }
    ]
    """
    training_data = []

    for conv in conversations:
        training_data.append({
            'messages': [
                {'role': 'system', 'content': SYSTEM_PROMPT},
                {'role': 'user', 'content': conv['pergunta']},
                {'role': 'assistant', 'content': conv['resposta']}
            ]
        })

    return training_data

# Salvar como JSONL
with open('training.jsonl', 'w', encoding='utf-8') as f:
    for item in training_data:
        f.write(json.dumps(item, ensure_ascii=False) + '\n')

Executar Fine-tuning

OpenAI:

# Upload do arquivo
openai api files.create -f training.jsonl -p fine-tune

# Criar job de fine-tuning
openai api fine_tuning.jobs.create \
  -t file-abc123 \
  -m gpt-3.5-turbo

# Monitorar
openai api fine_tuning.jobs.list

Usar Modelo Fine-tuned

const response = await openai.chat.completions.create({
  model: 'ft:gpt-3.5-turbo:sua-org::abc123',  // Seu modelo
  messages: [
    { role: 'user', content: userMessage }
  ]
});

Combinando Abordagens

Na pratica, a melhor solucao combina as tres:

async function smartChat(userMessage) {
  // 1. RAG para buscar contexto
  const context = await search(userMessage, 3);

  // 2. Prompt engineering para estruturar
  const prompt = buildPrompt(context, userMessage);

  // 3. Modelo fine-tuned para tom de voz
  const response = await openai.chat.completions.create({
    model: 'ft:gpt-3.5-turbo:sua-org::abc123',
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: prompt }
    ]
  });

  return response.choices[0].message.content;
}

Fontes de Dados Para Treinar

Do Seu Negocio

Fonte	O que Extrair
Site	Paginas de produto, FAQ, politicas
WhatsApp	Conversas reais (anonimizadas)
Email	Respostas padrao, templates
CRM	Historico de atendimento
Wiki interna	Processos, manuais

Estruturar Conversas do WhatsApp

import pandas as pd

def process_whatsapp_export(file_path):
    """
    Processa export do WhatsApp e cria pares pergunta/resposta
    """
    conversations = []
    current_customer = None
    current_question = None

    with open(file_path, 'r', encoding='utf-8') as f:
        for line in f:
            # Parse linha do WhatsApp
            # Formato: [DD/MM/YYYY, HH:MM] Remetente: Mensagem

            if is_customer_message(line):
                current_question = extract_message(line)
            elif is_agent_message(line) and current_question:
                answer = extract_message(line)
                conversations.append({
                    'pergunta': current_question,
                    'resposta': answer
                })
                current_question = None

    return conversations

Avaliando Qualidade

Metricas

1. Relevancia: Resposta faz sentido pra pergunta?
2. Precisao: Informacao esta correta?
3. Completude: Respondeu tudo que foi perguntado?
4. Tom: Esta no tom adequado?

Teste A/B

async function testResponse(userMessage) {
  const responseA = await chatWithModelA(userMessage);
  const responseB = await chatWithModelB(userMessage);

  // Log para avaliacao manual
  console.log(`
    Pergunta: ${userMessage}
    Modelo A: ${responseA}
    Modelo B: ${responseB}
  `);

  // Ou avaliacao automatica com outro LLM
  const evaluation = await evaluateResponses(userMessage, responseA, responseB);
  return evaluation;
}

Pipeline Completo

1. Coletar dados (documentos, conversas)
2. Limpar e estruturar
3. Dividir em chunks
4. Criar embeddings
5. Armazenar em banco vetorial
6. Testar retrieval
7. Ajustar prompts
8. Fine-tune se necessario
9. Avaliar qualidade
10. Iterar

Checklist de Implementacao

• Documentos coletados e organizados
• Chunks de tamanho adequado (300-500 tokens)
• Embeddings criados
• Banco vetorial configurado
• Busca semantica funcionando
• System prompt otimizado
• Testes com perguntas reais
• Metricas de qualidade definidas
• Pipeline de atualizacao documentado

---

Sakaguchi IA - Inteligencia Artificial para Empresas Brasileiras