De ABAP a Python: Guia de Integração de IA/ML para Desenvolvedores SAP no Brasil

A Verdade Inconveniente que Todo Desenvolvedor ABAP Precisa Ouvir

Escrevo ABAP há 12 anos. Pagou minha hipoteca, financiou dois carros e me deu uma carreira da qual me orgulho genuinamente. Relatórios ALV complexos, BAPIs personalizadas, enhancement spots profundamente aninhados em módulos de logística — eu construí tudo isso. E estou te dizendo agora, sem nenhuma agenda além da honestidade: se você não estiver aprendendo Python em 2026, você estará construindo uma carreira sobre bases cada vez menores.

Esta não é uma previsão pessimista. O SAP não vai desaparecer. A base instalada é enorme — mais de 400.000 clientes, trilhões de dólares em dados de negócios gerenciados em sistemas ECC e S/4HANA em todo o mundo. Desenvolvedores ABAP serão necessários por anos. Mas a forma do que fazemos está mudando mais rápido do que a maioria dos consultores está disposta a admitir. SAP Business AI, Joule, embedded analytics, clean core — cada um desses pilares estratégicos roda em Python, não em ABAP. O novo SAP está sendo construído em uma linguagem que você talvez ainda não conheça.

A boa notícia — e esta é a parte que realmente me anima — é que os desenvolvedores ABAP estão em uma posição única para vencer na era da IA/ML. Não apesar de nosso histórico SAP, mas por causa dele. O problema com a maioria das equipes de ciência de dados que constroem integrações SAP é que elas não entendem o que MARD ou VBRP realmente significam. Elas não sabem por que um período de lançamento é importante. Não conseguem diferenciar um indicador de débito de um documento de compensação. Você consegue. Esse conhecimento de domínio vale mais do que qualquer tutorial de NumPy.

Este guia é o que eu gostaria que alguém tivesse me entregado quando comecei minha transição. É prático, tem código real e respeita o fato de que você já sabe programar. Você não precisa ser tratado como um iniciante — você precisa de uma ponte.

Por que Desenvolvedores ABAP Têm uma Vantagem Injusta em IA/ML

Antes de escrevermos uma única linha de Python, vamos ser honestos sobre o que você já tem e que a maioria dos cientistas de dados não possui.

Você Entende os Dados com Profundidade de Negócio

Quando um modelo de machine learning é treinado em dados de vendas SAP, alguém precisa decidir quais tabelas usar, como lidar com entregas parciais, como é um documento de cancelamento e por que certas entradas devem ser excluídas. Um cientista de dados de fora do SAP passará meses descobrindo que VBRP-FKIMG é a quantidade faturada real e que você precisa fazer um join com VBRK para a moeda a nível de cabeçalho. Você já sabe disso. Você já escreveu as instruções SELECT. Você já depurou os dados.

Você Conhece os Processos por Trás dos Números

Modelos de IA/ML são inúteis sem engenharia de features, e a engenharia de features exige entender o que os dados significam. Você sabe que um pedido de compra com entrada de mercadoria, mas sem fatura, é um risco de apropriação. Você sabe que um bloqueio de entrega em um pedido de vendas significa coisas diferentes em diferentes empresas. Essa inteligência contextual é a diferença entre um modelo que pontua bem em um conjunto de validação e um que realmente funciona em produção.

Você Já Pensa em Fluxos de Dados

A programação ABAP é fundamentalmente sobre mover dados através de processos de negócio: ler de tabelas de banco de dados, transformar tabelas internas, chamar módulos de função, gravar de volta. A ciência de dados em Python segue exatamente o mesmo padrão: extrair dados de uma fonte, transformá-los em um DataFrame, executá-los através de um modelo, gravar os resultados de volta. O modelo mental se transfere quase diretamente.

Você Tem a Confiança da Organização

Colocar IA/ML em produção dentro de um ambiente SAP exige navegar por equipes de Basis, segurança, gerenciamento de transportes e aprovação de negócios. Você já fez tudo isso antes. Um cientista de dados júnior vindo de fora não tem nada disso. Seus relacionamentos existentes e conhecimento institucional são uma enorme vantagem quando chega a hora de implantar.

ABAP vs Python: Uma Comparação Honesta

Antes de escolher qual linguagem usar para uma determinada tarefa, você precisa de uma imagem honesta de ambas. Veja como 12 anos de ABAP e vários anos de Python realmente se parecem lado a lado:

A conclusão: essas linguagens não são concorrentes. São parceiras. ABAP lida com o interior do SAP; Python lida com tudo o que acontece com esses dados fora do SAP. Os profissionais mais valiosos em 2026 conhecem ambos.

Configurando Seu Ambiente de Desenvolvimento Python-SAP

Antes de qualquer código, você precisa de um ambiente de trabalho. Aqui está a configuração exata que uso e recomendo.

Pré-requisitos

• Python 3.11+ (baixe de python.org — evite a versão da Microsoft Store no Windows)
• SAP NetWeaver RFC SDK 7.50 (baixe de SAP Software Downloads — você precisa de um S-user)
• Biblioteca pyrfc (wrapper Python para o RFC SDK)
• Um sistema SAP de desenvolvimento com acesso RFC (peça à sua equipe de Basis uma destination RFC)
• VS Code com a extensão Python (opcional, mas fortemente recomendado)

Passo 1: Crie um Ambiente Virtual

Sempre use um ambiente virtual. Isso é o equivalente em Python a manter seu namespace de desenvolvimento limpo — você não polui a instalação global do Python com bibliotecas específicas do projeto.

# Crie um diretório de projeto
mkdir sap-python-dev
cd sap-python-dev

# Crie um ambiente virtual
python -m venv venv

# Ative-o (Linux/Mac)
source venv/bin/activate

# Ative-o (Windows)
venv\Scripts\activate

# Seu prompt agora deve mostrar o prefixo (venv)

Passo 2: Instale o SAP RFC SDK

Baixe nwrfc750P_13-70002755.zip (ou a versão mais recente) do SAP Software Downloads Center. Extraia-o para um caminho conhecido — eu uso /opt/sap/nwrfcsdk no Linux ou C:\nwrfcsdk no Windows.

# Linux: adicione o caminho da biblioteca SDK ao seu ambiente
export SAPNWRFC_HOME=/opt/sap/nwrfcsdk
export LD_LIBRARY_PATH=$SAPNWRFC_HOME/lib:$LD_LIBRARY_PATH

# Ou adicione-os permanentemente ao ~/.bashrc

Passo 3: Instale as Bibliotecas Python

pip install pyrfc pandas scikit-learn matplotlib anthropic python-dotenv

Breve resumo do que cada um faz:

• pyrfc — conecta Python ao SAP via RFC (a ponte principal)
• pandas — sua nova tabela interna. DataFrames são essenciais para tudo o que se segue
• scikit-learn — a biblioteca padrão de machine learning para dados estruturados/tabulares
• matplotlib — gráficos e visualização
• anthropic — cliente da API Claude para integração LLM (usado no Projeto #3)
• python-dotenv — carrega credenciais de um arquivo .env, mantém segredos fora do código

Passo 4: Armazene Suas Credenciais SAP com Segurança

Crie um arquivo .env na raiz do seu projeto. Adicione-o ao .gitignore imediatamente.

SAP_HOST=seu-hostname-sap.empresa.com
SAP_SYSNR=00
SAP_CLIENT=100
SAP_USER=RFC_USER
SAP_PASSWORD=sua-senha
SAP_LANG=PT
ANTHROPIC_API_KEY=sk-ant-sua-chave-aqui

Seu Primeiro Script Python-SAP: Lendo um Cadastro de Material

Vamos começar com algo que você conhece completamente em ABAP e replicá-lo em Python. Leremos dados básicos de material usando RFC_READ_TABLE — a primeira parada de um desenvolvedor ABAP ao conectar ferramentas externas ao SAP.

O Jeito ABAP

*&---------------------------------------------------------------------*
*& Report: Read material master data
*&---------------------------------------------------------------------*
REPORT z_material_read.

DATA: lt_mara TYPE TABLE OF mara,
      ls_mara TYPE mara.

SELECT matnr mtart matkl meins
  FROM mara
  INTO TABLE lt_mara
  WHERE mtart = 'FERT'
  AND   maktx NE space
  UP TO 100 ROWS.

LOOP AT lt_mara INTO ls_mara.
  WRITE: / ls_mara-matnr,
           ls_mara-mtart,
           ls_mara-matkl,
           ls_mara-meins.
ENDLOOP.

O Equivalente em Python (usando pyrfc)

import pyrfc
import pandas as pd
from dotenv import load_dotenv
import os

load_dotenv()

# Estabelece conexão RFC — equivalente a configurar uma trusted RFC destination
conn = pyrfc.Connection(
    ashost=os.getenv("SAP_HOST"),
    sysnr=os.getenv("SAP_SYSNR"),
    client=os.getenv("SAP_CLIENT"),
    user=os.getenv("SAP_USER"),
    passwd=os.getenv("SAP_PASSWORD"),
    lang=os.getenv("SAP_LANG", "EN")
)

# Chama RFC_READ_TABLE — a função universal de extração de dados SAP
result = conn.call(
    "RFC_READ_TABLE",
    QUERY_TABLE="MARA",
    DELIMITER="|",
    FIELDS=[
        {"FIELDNAME": "MATNR"},
        {"FIELDNAME": "MTART"},
        {"FIELDNAME": "MATKL"},
        {"FIELDNAME": "MEINS"},
    ],
    OPTIONS=[
        {"TEXT": "MTART = 'FERT'"}
    ],
    ROWCOUNT=100
)

# Analisa os resultados em um pandas DataFrame
rows = []
for entry in result["DATA"]:
    fields = entry["WA"].split("|")
    rows.append({
        "MATNR": fields[0].strip(),
        "MTART": fields[1].strip(),
        "MATKL": fields[2].strip(),
        "MEINS": fields[3].strip(),
    })

df = pd.DataFrame(rows)
print(df.head(10))
print(f"\nTotal de materiais recuperados: {len(df)}")

conn.close()

Observe a semelhança estrutural: conectar, definir o que você quer, executar, iterar pelos resultados. Os conceitos são idênticos — apenas a sintaxe muda. Após uma semana de Python, esse padrão se torna uma segunda natureza para qualquer desenvolvedor ABAP experiente.

Usando BAPI_MATERIAL_GET_ALL para Dados Mais Ricos

Para uso em produção, chamar uma BAPI adequada é mais limpo do que RFC_READ_TABLE:

result = conn.call(
    "BAPI_MATERIAL_GET_ALL",
    MATERIAL="000000000010000001",
    PLANT="1000"
)

# BAPIs retornam saída estruturada — acesse os campos diretamente
general_data = result.get("GENERALDATA", {})
print(f"Material: {general_data.get('MATERIAL')}")
print(f"Tipo: {general_data.get('MATL_TYPE')}")
print(f"Unidade Base: {general_data.get('BASE_UOM')}")

Extração de Dados para IA: Obtendo Dados SAP em DataFrames pandas

O verdadeiro poder começa quando você começa a puxar conjuntos de dados maiores para análise. DataFrames pandas são o equivalente em Python das tabelas internas ABAP, mas com capacidades integradas para análise, agrupamento, pivoteamento e operações estatísticas que exigiriam centenas de linhas de código ABAP.

Mapeamento de Tipos ABAP para Python/pandas

Uma Função de Extração de Dados de Nível de Produção

import pyrfc
import pandas as pd
from decimal import Decimal
import os
from dotenv import load_dotenv

load_dotenv()

def get_sap_connection():
    """Retorna uma conexão RFC reutilizável."""
    return pyrfc.Connection(
        ashost=os.getenv("SAP_HOST"),
        sysnr=os.getenv("SAP_SYSNR"),
        client=os.getenv("SAP_CLIENT"),
        user=os.getenv("SAP_USER"),
        passwd=os.getenv("SAP_PASSWORD"),
        lang="EN"
    )

def extract_table_to_df(conn, table_name, fields, where_clauses=None, max_rows=50000):
    """
    Extrai qualquer tabela transparente SAP para um pandas DataFrame.

    Args:
        conn: pyrfc.Connection ativa
        table_name: Nome da tabela SAP (ex: 'VBRP')
        fields: lista de nomes de campos a extrair
        where_clauses: lista de strings de cláusulas WHERE (máximo 72 caracteres cada!)
        max_rows: limite de linhas (cuidado com tabelas grandes)

    Returns:
        pandas DataFrame
    """
    options = []
    if where_clauses:
        for clause in where_clauses:
            # SAP RFC_READ_TABLE exige cláusulas com menos de 72 caracteres
            if len(clause) > 72:
                raise ValueError(f"Cláusula WHERE muito longa (>72 caracteres): {clause}")
            options.append({"TEXT": clause})

    result = conn.call(
        "RFC_READ_TABLE",
        QUERY_TABLE=table_name,
        DELIMITER="|",
        FIELDS=[{"FIELDNAME": f} for f in fields],
        OPTIONS=options,
        ROWCOUNT=max_rows
    )

    # Obtém metadados de campo para análise precisa
    field_meta = result["FIELDS"]
    field_names = [f["FIELDNAME"] for f in field_meta]

    rows = []
    for entry in result["DATA"]:
        parts = entry["WA"].split("|")
        row = {field_names[i]: parts[i].strip() if i < len(parts) else ""
               for i in range(len(field_names))}
        rows.append(row)

    return pd.DataFrame(rows) if rows else pd.DataFrame(columns=field_names)

O limite de 72 caracteres nas cláusulas WHERE é um clássico "gotcha" do SAP que pega todo desenvolvedor novo no RFC_READ_TABLE. Agora você não será um deles.

Projeto Real de IA/ML #1: Previsão de Demanda com scikit-learn

É aqui que o investimento vale a pena. Construiremos um modelo de previsão de demanda usando dados históricos de vendas do SAP — algo que todo ambiente SAP tem, mas poucas organizações realmente usam para previsão impulsionada por ML.

O Problema de Negócio

Um gerente de logística quer saber: para cada material de produto acabado, quantas unidades venderemos no próximo mês? Atualmente, isso é feito no Excel ou via planejamento integrado do SAP (que exige consultores MM/PP e configuração cara). Vamos construir um modelo Python que lê dados históricos de faturamento do VBRP e produz previsões.

Passo 1: Extrair Dados Históricos de Vendas

conn = get_sap_connection()

# Extrair itens de linha de documentos de faturamento — VBRP com join em VBRK para datas
# Nota: RFC_READ_TABLE não pode fazer JOINs, então extraímos separadamente e mesclamos no pandas
vbrp_df = extract_table_to_df(
    conn,
    table_name="VBRP",
    fields=["VBELN", "MATNR", "FKIMG", "VRKME", "NETWR", "WAERK"],
    where_clauses=["VBTYP = 'M'"],  # M = Fatura (documento de faturamento)
    max_rows=200000
)

vbrk_df = extract_table_to_df(
    conn,
    table_name="VBRK",
    fields=["VBELN", "FKDAT", "BUKRS"],
    where_clauses=["VBTYP = 'M'", "AND FKDAT >= '20230101'"],
    max_rows=200000
)

conn.close()

# Mesclar pelo número do documento de faturamento
df = pd.merge(vbrp_df, vbrk_df, on="VBELN", how="inner")

# Conversões de tipo — passo crítico para desenvolvedores ABAP novos no pandas
df["FKIMG"] = pd.to_numeric(df["FKIMG"], errors="coerce").fillna(0)
df["FKDAT"] = pd.to_datetime(df["FKDAT"], format="%Y%m%d", errors="coerce")
df["MATNR"] = df["MATNR"].str.strip()

# Remover cancelamentos (quantidades negativas)
df = df[df["FKIMG"] > 0]

print(f"Extraídos {len(df):,} itens de linha de faturamento")
print(df.head())

Passo 2: Engenharia de Features

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, r2_score
import numpy as np

# Agrupar para vendas mensais por material
df["year_month"] = df["FKDAT"].dt.to_period("M")
monthly = df.groupby(["MATNR", "year_month"])["FKIMG"].sum().reset_index()
monthly.columns = ["MATNR", "year_month", "quantity_sold"]

# Focar em um material para demonstração — em produção você faria um loop ou usaria um modelo por material
material = "000000000010000001"
mat_df = monthly[monthly["MATNR"] == material].copy()
mat_df = mat_df.sort_values("year_month")

# Converter período para índice numérico para regressão (número do mês desde o início)
mat_df["month_index"] = range(len(mat_df))

# Adicionar features sazonais — o mês do ano importa para muitos produtos
mat_df["month_of_year"] = mat_df["year_month"].dt.month
mat_df["quarter"] = mat_df["year_month"].dt.quarter

# Codificação one-hot do mês do ano (captura sazonalidade)
month_dummies = pd.get_dummies(mat_df["month_of_year"], prefix="month")
mat_df = pd.concat([mat_df, month_dummies], axis=1)

print(f"Dados de treinamento: {len(mat_df)} meses de histórico")

Passo 3: Treinar o Modelo de Previsão

# Definir features — tendência (month_index) + sazonalidade (month dummies)
feature_cols = ["month_index"] + [c for c in mat_df.columns if c.startswith("month_")]
X = mat_df[feature_cols]
y = mat_df["quantity_sold"]

# Divisão treino/teste — usar os últimos 3 meses como holdout (divisão respeitando o tempo)
X_train, X_test = X.iloc[:-3], X.iloc[-3:]
y_train, y_test = y.iloc[:-3], y.iloc[-3:]

# Treinar modelo de Regressão Linear
model = LinearRegression()
model.fit(X_train, y_train)

# Avaliar
y_pred = model.predict(X_test)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"Erro Absoluto Médio: {mae:.0f} unidades")
print(f"Score R²: {r2:.3f}")

# Prever para o próximo mês
last_index = mat_df["month_index"].max() + 1
next_month_num = (mat_df["year_month"].max() + 1).month
next_features = {"month_index": last_index}
for col in feature_cols:
    if col.startswith("month_"):
        month_num = int(col.split("_")[1])
        next_features[col] = 1 if month_num == next_month_num else 0

next_X = pd.DataFrame([next_features])
forecast = model.predict(next_X)[0]
print(f"\nPrevisão para o próximo mês: {forecast:.0f} unidades")

Em uma implantação de produção, você envolveria isso em um script Python agendado que grava as previsões de volta no SAP usando uma tabela Z customizada via BAPI_PRODORD_CREATE ou similar, ou em um InfoObject do BW via carga de arquivo plano. A lógica de previsão permanece em Python; os resultados voltam para o SAP, onde os planejadores podem usá-los.

Projeto Real de IA/ML #2: Detecção de Anomalias em Documentos FI

Fraudes em contas a pagar e erros de lançamento custam milhões às organizações. A revisão manual é impossível em escala. O Isolation Forest — um algoritmo de machine learning não supervisionado — se destaca em encontrar os documentos que "não se parecem com os outros". Vamos construí-lo com dados BKPF/BSEG.

Extrair Dados de Lançamento Financeiro

conn = get_sap_connection()

# BKPF: Cabeçalho do documento FI
bkpf_df = extract_table_to_df(
    conn,
    table_name="BKPF",
    fields=["BELNR", "GJAHR", "BUKRS", "BLDAT", "BUDAT", "BLART", "USNAM", "BKTXT"],
    where_clauses=["GJAHR = '2025'", "AND BUKRS = '1000'"],
    max_rows=100000
)

# BSEG: Itens de linha do documento FI
bseg_df = extract_table_to_df(
    conn,
    table_name="BSEG",
    fields=["BELNR", "GJAHR", "BUZEI", "KOART", "DMBTR", "SHKZG", "HKONT", "LIFNR", "KUNNR"],
    where_clauses=["GJAHR = '2025'", "AND BUKRS = '1000'"],
    max_rows=500000
)

conn.close()

# Conversões de tipo
bkpf_df["BLDAT"] = pd.to_datetime(bkpf_df["BLDAT"], format="%Y%m%d", errors="coerce")
bkpf_df["BUDAT"] = pd.to_datetime(bkpf_df["BUDAT"], format="%Y%m%d", errors="coerce")
bseg_df["DMBTR"] = pd.to_numeric(bseg_df["DMBTR"], errors="coerce").fillna(0)

# Convenção de sinal: SHKZG='S' é débito, 'H' é crédito
bseg_df["signed_amount"] = bseg_df.apply(
    lambda r: r["DMBTR"] if r["SHKZG"] == "S" else -r["DMBTR"], axis=1
)

Engenharia de Features para Detecção de Anomalias

from sklearn.ensemble import IsolationForest
from sklearn.preprocessing import LabelEncoder
import warnings
warnings.filterwarnings("ignore")

# Mesclar cabeçalho e itens de linha
df_fi = pd.merge(bseg_df, bkpf_df, on=["BELNR", "GJAHR"], how="left")

# Criar features que capturam comportamento de lançamento anômalo
features_df = pd.DataFrame()

# Feature 1: Valor absoluto (valores incomumente grandes são suspeitos)
features_df["abs_amount"] = df_fi["signed_amount"].abs()

# Feature 2: Dia da semana em que o documento foi lançado (lançamentos de fim de semana são arriscados)
features_df["day_of_week"] = df_fi["BUDAT"].dt.dayofweek

# Feature 3: Diferença entre data do documento e data de lançamento (grandes lacunas = suspeito)
features_df["date_gap_days"] = (df_fi["BUDAT"] - df_fi["BLDAT"]).dt.days.abs().fillna(0)

# Feature 4: Tipo de documento codificado como numérico
le = LabelEncoder()
features_df["doc_type_encoded"] = le.fit_transform(df_fi["BLART"].fillna("XX"))

# Feature 5: Tipo de conta (fornecedor, cliente, GL) codificado
features_df["acct_type_encoded"] = le.fit_transform(df_fi["KOART"].fillna("X"))

# Feature 6: Valor transformado por log (reduz o impacto de outliers extremos no treinamento do modelo)
features_df["log_amount"] = np.log1p(features_df["abs_amount"])

# Remover linhas com NaN (documentos com datas ausentes, etc.)
features_clean = features_df.dropna()
print(f"Treinando em {len(features_clean):,} itens de linha FI")

Treinar e Pontuar o Isolation Forest

from sklearn.preprocessing import StandardScaler

# Escalar features — Isolation Forest não é sensível à escala, mas é uma boa prática
scaler = StandardScaler()
X_scaled = scaler.fit_transform(features_clean)

# Treinar Isolation Forest
# contamination=0.01 significa que esperamos ~1% dos lançamentos como anômalos
iso_forest = IsolationForest(
    n_estimators=200,
    contamination=0.01,
    random_state=42,
    n_jobs=-1
)
iso_forest.fit(X_scaled)

# Pontuar todos os documentos — pontuação menor = mais anômalo
anomaly_scores = iso_forest.decision_function(X_scaled)
predictions = iso_forest.predict(X_scaled)  # -1 = anomalia, 1 = normal

# Adicionar resultados de volta ao DataFrame original
results_df = df_fi.loc[features_clean.index].copy()
results_df["anomaly_score"] = anomaly_scores
results_df["is_anomaly"] = predictions == -1

# Relatar as principais anomalias para revisão humana
anomalies = results_df[results_df["is_anomaly"]].sort_values("anomaly_score")
print(f"\nSinalizados {len(anomalies):,} documentos para revisão ({len(anomalies)/len(results_df)*100:.1f}%)")
print("\nTop 10 documentos mais anômalos:")
print(anomalies[["BELNR", "GJAHR", "BLART", "signed_amount", "USNAM", "anomaly_score"]].head(10))

A saída é uma lista classificada de documentos FI que parecem estatisticamente incomuns em comparação com seus padrões históricos de lançamento. Nem todo documento sinalizado é fraudulento — alguns são transações legítimas grandes ou ajustes de fim de ano. Mas o modelo reduz drasticamente a carga de trabalho de revisão: em vez de auditar 100.000 lançamentos, um auditor revisa os 1.000 principais itens sinalizados. Isso é uma redução de 99% no esforço manual.

Projeto Real de IA/ML #3: Descrições de Relatórios SAP com LLM

Este é o que realmente surpreende os usuários de negócios todas as vezes. Pegamos a saída de um relatório ABAP padrão — o tipo de tabela críptica cheia de tipos de movimento e chaves de conta que apenas um consultor de logística pode ler — e usamos Claude (o LLM da Anthropic) para traduzi-lo para um português claro que qualquer gerente pode entender.

A Configuração

import anthropic
import pandas as pd
import json
from dotenv import load_dotenv
import os

load_dotenv()

client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

Extrair os Dados do Relatório

conn = get_sap_connection()

# Exemplo: Dados de movimento de material do MSEG
mseg_df = extract_table_to_df(
    conn,
    table_name="MSEG",
    fields=["MBLNR", "MJAHR", "ZEILE", "MATNR", "WERKS", "LGORT",
            "BWART", "MENGE", "MEINS", "DMBTR", "WAERS"],
    where_clauses=[
        "MJAHR = '2025'",
        "AND WERKS = '1000'",
        "AND BWART IN ('101', '102', '201', '261', '311', '312')"
    ],
    max_rows=10000
)

conn.close()

# Conversões de tipo
mseg_df["MENGE"] = pd.to_numeric(mseg_df["MENGE"], errors="coerce").fillna(0)
mseg_df["DMBTR"] = pd.to_numeric(mseg_df["DMBTR"], errors="coerce").fillna(0)

# Resumir para o LLM (não envie 10.000 linhas — resuma primeiro)
summary = mseg_df.groupby("BWART").agg(
    movement_count=("MBLNR", "count"),
    total_qty=("MENGE", "sum"),
    total_value=("DMBTR", "sum")
).reset_index()

# Converter para uma string similar a JSON para o prompt
summary_text = summary.to_string(index=False)
print("Resumo de movimento preparado para LLM:")
print(summary_text)

Gerar a Explicação em Português Claro

def explain_sap_report(report_data: str, report_context: str) -> str:
    """
    Envia dados de relatório SAP para Claude para explicação em português claro.

    Args:
        report_data: Os dados reais (como string formatada ou CSV)
        report_context: Contexto sobre o que o relatório mostra

    Returns:
        Explicação legível por humanos de Claude
    """
    prompt = f"""Você é um assistente de analista de negócios SAP. Um usuário executou um relatório de gestão de materiais SAP
e precisa que ele seja explicado em português claro para um público de negócios não técnico.

Contexto do relatório: {report_context}

Dados do relatório:
{report_data}

Referência de tipo de movimento SAP:
- 101: Entrada de mercadoria para pedido de compra
- 102: Estorno de entrada de mercadoria para pedido de compra
- 201: Saída de mercadoria para centro de custo
- 261: Saída de mercadoria para ordem de produção
- 311: Transferência de estoque de centro para centro (entrada)
- 312: Transferência de estoque de centro para centro (saída)

Por favor, forneça:
1. Um resumo executivo de 2-3 frases sobre o que este relatório mostra
2. Observações chave (o que se destaca — volumes, valores, padrões incomuns)
3. Quaisquer ações recomendadas ou perguntas que um proprietário de negócio deveria fazer
4. Explicação em português claro de cada tipo de movimento presente nos dados

Escreva em linguagem clara e sem jargões, adequada para um gerente de cadeia de suprimentos que não conhece SAP."""

    message = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=1024,
        messages=[
            {"role": "user", "content": prompt}
        ]
    )

    return message.content[0].text


# Gerar a explicação
context = "Movimentos de material na Planta 1000 para o ano fiscal de 2025, mostrando todas as entradas, saídas e transferências de mercadorias."
explanation = explain_sap_report(summary_text, context)

print("\n" + "="*60)
print("EXPLICAÇÃO DO RELATÓRIO EM PORTUGUÊS CLARO")
print("="*60)
print(explanation)

A saída é um resumo gerencial automaticamente gerado de qualquer relatório SAP. Você pode envolver isso em uma interface web simples usando FastAPI e implantá-lo em dias. Os usuários de negócios executam uma transação, clicam em "Explicar este relatório" e obtêm um parágrafo que podem colar diretamente em um e-mail gerencial. Esse tipo de aumento de IA é onde o conhecimento ABAP e as habilidades em Python se combinam para criar valor de negócio genuíno e imediato.

O Caminho de Aprendizado de 90 Dias: De Zero Python ao Primeiro Modelo de ML em Produção

Aprender Python enquanto mantém sua carreira SAP não exige que você largue seu emprego ou faça um bootcamp. Aqui está o caminho realista que eu daria a um desenvolvedor ABAP sênior começando hoje.

Dias 1–15: Fundamentos de Python (Mapeado para ABAP)

• Dia 1-2: Instale Python, VS Code e seu ambiente virtual. Execute seu primeiro script. O objetivo é um ambiente de trabalho, não aprender sintaxe.
• Dia 3-5: Fundamentos da sintaxe Python através de uma lente ABAP. Variáveis (não precisa de declaração DATA), loops (FOR em vez de LOOP AT), funções (equivalente a FORM/FUNCTION é def). Use o livro Python Crash Course ou o tutorial oficial do Python — pule qualquer coisa sobre web scraping ou jogos e foque em tipos de dados e funções.
• Dia 6-8: Dicionários e listas. Estes são seus equivalentes de tabelas internas. Um dicionário Python é uma única estrutura como uma área de trabalho; uma lista de dicionários é uma tabela interna. Este modelo mental acelerará todo o resto.
• Dia 9-12: Fundamentos do pandas. Leia a introdução oficial de 10 minutos do pandas. Pratique: df.head(), df.describe(), df.groupby(), df.merge(). Essas quatro operações cobrirão 80% do que você precisa para trabalhar com dados SAP.
• Dia 13-15: Conecte Python ao seu sistema de desenvolvimento SAP usando pyrfc. Faça o script de cadastro de material deste artigo funcionar. Quando funcionar, você sentirá a mesma satisfação de escrever sua primeira instrução SELECT ABAP funcionando.

Dias 16–45: Engenharia de Dados SAP

• Dia 16-20: Extraia 3 diferentes conjuntos de dados SAP que você conhece bem (materiais, clientes, pedidos de compra). Construa DataFrames. Pratique joins, agregações e conversões de tipo. O objetivo é fluência com seus próprios dados.
• Dia 21-30: Aprenda pandas para limpeza de dados. Dados SAP reais são confusos — entradas duplicadas, espaços em branco à direita, formatos de data incorretos, registros de valor zero que devem ser excluídos. Construa um pipeline de limpeza reutilizável para dados SAP.
• Dia 31-38: matplotlib e plotly para visualização. Construa 5 gráficos a partir de dados SAP: tendência de vendas ao longo do tempo, principais materiais por receita, detalhamento de tipo de movimento, envelhecimento de pagamentos a fornecedores, consumo de material por planta. A visualização é onde os usuários de negócios veem o valor pela primeira vez.
• Dia 39-45: Agende um script Python para rodar diariamente via cron (Linux) ou Agendador de Tarefas (Windows). Extraia dados SAP, produza um CSV de resumo, envie-o por e-mail usando o smtplib do Python. Esta é sua primeira implantação "em produção".

Dias 46–75: Machine Learning em Dados SAP

• Dia 46-55: Fundamentos do scikit-learn. Percorra a seção do guia oficial do usuário sobre aprendizado supervisionado. Foque em: LinearRegression, RandomForestRegressor e o padrão de divisão treino/teste. Não tente aprender tudo — aprenda o workflow.
• Dia 56-60: Construa o modelo de previsão de demanda deste artigo em seus próprios dados. Ajuste-o para um material ou grupo de materiais que seja significativo em sua organização. Mostre a saída para alguém do planejamento — o feedback real acelera o aprendizado mais rápido do que qualquer curso.
• Dia 61-68: Construa o modelo de detecção de anomalias em seus dados FI. Sente-se com a equipe financeira e revise os documentos sinalizados juntos. Você aprenderá mais sobre o que "anômalo" significa em seu contexto específico em uma reunião do que em qualquer tutorial.
• Dia 69-75: Aprenda os fundamentos da avaliação de modelos: matriz de confusão, precisão/recall (para classificação), MAE/RMSE (para regressão) e validação cruzada. Você não precisa dominar estatísticas — você precisa saber como dizer se seu modelo está funcionando.

Dias 76–90: Implantação e Posicionamento

• Dia 76-80: Fundamentos do FastAPI. Envolva seu modelo de ML em uma API REST simples — um endpoint que aceita um número de material e retorna uma previsão. Isso torna seu modelo acessível a qualquer um que possa fazer uma requisição HTTP, incluindo aplicativos Fiori.
• Dia 81-85: Git e GitHub. Controle de versão é inegociável para o desenvolvimento Python. Aprenda git init, git add, git commit, git push. Crie uma conta GitHub e envie seus projetos SAP-Python. Isso se torna seu portfólio.
• Dia 86-90: Apresente seu modelo de previsão de demanda ou detecção de anomalias a um stakeholder de negócio. Não precisa ser perfeito — precisa ser útil. Um modelo funcional que detecta uma fatura fraudulenta ou melhora um ciclo de planejamento em 10% é uma prova de conceito que abre portas.

O que Estudar (Recursos Específicos)

O Roteiro de 12 Meses: Do Primeiro Script à IA/ML em Produção

O caminho de 90 dias anterior neste artigo o leva ao seu primeiro modelo implantado. Aqui está a visão estendida de 12 meses — para onde você vai depois que essa base estiver sólida, e quais marcos indicam que você está no caminho certo para os cargos híbridos SAP+Python que pagam no topo do mercado.

Duas coisas tornam este roteiro realista que planos semelhantes ignoram. Primeiro, você está construindo coisas reais que usuários reais podem ver — não projetos de tutorial. Cada marco acima tem uma saída visível para um stakeholder de negócio. Isso importa porque constrói sua reputação interna e cria a base de evidências que você precisa ao se posicionar para melhores cargos. Segundo, os marcos se somam: a integração LLM do Mês 4 se baseia no modelo do Mês 3, que se baseia na engenharia de dados do Mês 2. Você não está começando do zero a cada mês — você está acumulando.

Os dados salariais apoiam essa linha do tempo. Desenvolvedores ABAP que completam este caminho de 12 meses e podem demonstrá-lo com um portfólio GitHub e uma implantação ao vivo geralmente entram em cargos híbridos com salários de R$ 30.000 a R$ 40.000 mensais no mercado brasileiro, em comparação com R$ 20.000 a R$ 28.000 para perfis ABAP-only equivalentes. Os 12 meses de investimento se pagam no primeiro ano do novo nível de remuneração.

Implicações de Carreira: O Mercado Híbrido SAP+Python em 2026

Vamos falar de dinheiro e oportunidades, porque é isso que, em última análise, torna o investimento no aprendizado que vale a pena.

A Lacuna Salarial é Real

Em 2026, os quadros de empregos contam uma história clara. Cargos de desenvolvedor ABAP puro (sem Python, sem IA) no Brasil, para perfis sêniores, podem variar entre R$ 20.000 e R$ 28.000 mensais. Adicione habilidades comprovadas em Python e pandas — mesmo sem ML — e esses mesmos perfis saltam para R$ 25.000 a R$ 35.000. Adicione um ou dois modelos de ML implantados a um portfólio, e você estará olhando para R$ 30.000 a R$ 45.000 para cargos híbridos SAP+AI em consultorias, grandes empresas e parceiros SAP. Nos EUA, o equivalente é aproximadamente US$ 115K–US$ 195K dependendo da localização e do empregador.

O prêmio existe porque a oferta de pessoas que entendem os dois lados é minúscula. Um cientista de dados que não conhece SAP não pode construir o que você construirá depois de ler este artigo. Um desenvolvedor ABAP que não aprendeu Python está excluído da onda da IA. A sobreposição — pessoas que podem fazer as duas coisas — é onde a remuneração atinge o pico.

Onde Esses Cargos Estão Surgindo

• Parceiros SAP e Integradores de Sistemas: Accenture, Deloitte, Capgemini, IBM, e grandes consultorias brasileiras como Stefanini, CI&T, T-Systems, todas têm práticas dedicadas a SAP+IA. Esses cargos são rotulados como "Engenheiro de Dados SAP", "Desenvolvedor SAP ML" ou "Consultor SAP AI". Eles pagam taxas de consultoria e oferecem exposição a múltiplos clientes.
• A própria SAP SE: A SAP está construindo agressivamente capacidades de Business AI no S/4HANA. Eles contratam desenvolvedores ABAP que podem trabalhar com suas plataformas de analytics embarcados e AI Core. Procure no LinkedIn por cargos de "SAP Business AI".
• Grandes Clientes SAP: Empresas de manufatura, farmacêuticas e automotivas que operam ambientes SAP complexos estão construindo equipes internas de IA. Elas querem pessoas que entendam os processos de negócio codificados em seus sistemas SAP — não apenas cientistas de dados que precisam de 18 meses para aprender o modelo de dados.
• Startups: Um número crescente de empresas está construindo produtos de análise baseados em IA sobre dados SAP (análise de compras, otimização de capital de giro, inteligência da cadeia de suprimentos). Essas startups podem pagar um pouco abaixo das grandes empresas, mas oferecem participação acionária e a aceleração de aprendizado mais rápida que você encontrará em qualquer lugar.

Como Se Posicionar

A chave é não se apresentar como "um desenvolvedor ABAP que também sabe Python". Essa abordagem subestima a combinação. Apresente-se como "um engenheiro de processos de negócio que pode construir soluções de IA em dados SAP" — porque é isso que você realmente é depois de completar este caminho de aprendizado.

Seu perfil no LinkedIn deve mencionar: os módulos SAP que você conhece profundamente (FI, MM, SD, PP — o que for aplicável), Python, pandas, scikit-learn e qualquer modelo ou automação implantado que você tenha construído. Mesmo um projeto pessoal conta. Um repositório GitHub com notebooks de análise de dados SAP é um portfólio que 95% dos desenvolvedores ABAP não conseguem produzir, o que o diferencia imediatamente.

A Questão da Certificação

Certificações importam menos do que código implantado. Uma certificação PCEP do Python Institute sinaliza que você aprendeu Python. Um repositório GitHub com um modelo de previsão de demanda SAP funcionando sinaliza que você pode aplicá-lo. Priorize o último. Se você quiser uma credencial, a SAP Certified Technology Associate — SAP Analytics Cloud é mais relevante para o mercado do que uma certificação Python genérica, porque demonstra contexto SAP junto com capacidade analítica.

Erros Comuns que Desenvolvedores ABAP Cometem ao Aprender Python

Eu cometi a maioria deles. Você não precisa.

Erro 1: Usar Loops em Vez de Vetorização

Desenvolvedores ABAP instintivamente escrevem loops em Python da mesma forma que escreveriam LOOP AT em ABAP. Isso funciona, mas é lento com grandes conjuntos de dados e não é "Pythonic". Aprenda as operações vetorizadas do pandas cedo. Em vez de:

# Python com mentalidade ABAP (lento, não-Pythonic)
for index, row in df.iterrows():
    if row["BWART"] == "101":
        df.at[index, "movement_desc"] = "Goods Receipt"

Escreva:

# Operação vetorizada Pythonic (rápida, limpa)
movement_map = {"101": "Goods Receipt", "102": "GR Reversal", "261": "Goods Issue"}
df["movement_desc"] = df["BWART"].map(movement_map)

Erro 2: Ignorar Tipos de Dados Após a Extração

RFC_READ_TABLE retorna tudo como strings. Desenvolvedores ABAP que não convertem explicitamente os tipos de dados descobrem que as agregações retornam 0 ou erros. Sempre converta campos numéricos com pd.to_numeric() e datas com pd.to_datetime() imediatamente após a extração.

Erro 3: Treinar em Todos os Dados Disponíveis Sem Validação

Em ABAP, você faz SELECT nos dados e os exibe — não há conceito de overfitting. Em ML, um modelo treinado sem um conjunto de validação adequado pode pontuar perfeitamente nos dados de treinamento e falhar completamente em novos dados. Sempre use train_test_split, e para dados SAP de séries temporais, sempre divida cronologicamente (não aleatoriamente).

Erro 4: Tentar Aprender Tudo Antes de Construir Qualquer Coisa

O caminho de aprendizado ABAP é estruturado — você estuda a sintaxe, os tipos de dados, o modelo de objeto. O ecossistema do Python é vasto o suficiente para que tentar aprender tudo antes de começar o paralise. Construa algo real com o que você sabe depois de duas semanas. As lacunas em seu conhecimento se tornarão óbvias e direcionadas assim que você encontrar um problema real.

Considerações Finais: A Ponte é Mais Curta do que Você Pensa

Quando executei meu primeiro script pyrfc e vi os dados SAP aparecerem em um DataFrame do pandas, lembro de ter pensado: estes são os mesmos dados que eu venho olhando há 12 anos, mas agora eu posso realmente fazer coisas com eles. Os dados não mudaram. Os problemas de negócio não mudaram. Mas as ferramentas que eu podia aplicar a eles se expandiram enormemente.

Você já entende algo que nenhum tutorial de Python pode ensinar: por que os dados no SAP são como são, o que eles representam em um processo de negócio real e o que as mudanças nesses dados realmente significam para as pessoas que dependem deles. Esse conhecimento é sua base. Python é apenas um conjunto de ferramentas mais poderoso para construir sobre ele.

O caminho de 90 dias neste artigo é realizável junto com uma carreira ABAP em tempo integral. Você não precisa de noites e fins de semana — você precisa de 30-45 minutos focados por dia, consistentemente. Após três meses, você terá código funcionando, um portfólio no GitHub e a confiança para começar a se posicionar para os cargos que estão surgindo na interseção de SAP e IA.

Os desenvolvedores ABAP que prosperarão na próxima década não serão aqueles que abandonaram sua expertise em SAP. Serão aqueles que a mantiveram e adicionaram Python. Essa combinação — profundo conhecimento de processos de negócio mais ferramentas modernas de IA/ML — é genuinamente rara, genuinamente valiosa e disponível para todo desenvolvedor disposto a investir tempo.

Runtime Python no BTP vs. Scripts Python On-Premise: Qual Você Deve Usar?

Uma das decisões mais práticas que os desenvolvedores ABAP enfrentam ao construir suas primeiras integrações Python-SAP é onde executar o código. A resposta depende do seu ambiente, da sua postura de segurança e da criticidade da carga de trabalho. Aqui está uma comparação honesta baseada na implantação de ambos em ambientes de produção.

Scripts Python On-Premise: Comece Por Aqui

Executar Python em um servidor dentro da sua rede significa conectar-se ao SAP via pyrfc ou uma conexão HANA direta de uma VM Linux ou servidor Windows dentro da sua DMZ SAP. Essa abordagem é a mais rápida para começar: sem aquisição de nova infraestrutura, sem configuração de conta BTP, sem processo de aprovação na nuvem. Instale Python, instale pyrfc, escreva um script, execute-o. Um cron job em um servidor Linux executando extrações noturnas de dados, relatórios semanais e jobs mensais de pontuação de ML é confiável, barato e não exige novos contratos com fornecedores.

Para ambientes "air-gapped" em governos, defesa ou manufatura farmacêutica, o on-premise é frequentemente a única opção. Para 80% dos casos de uso que os desenvolvedores ABAP constroem nos primeiros 12 meses de trabalho com Python, o Python on-premise é suficiente e dramaticamente mais rápido de implantar do que qualquer alternativa baseada em nuvem.

Runtime Python no SAP BTP: Quando Você Realmente Precisa Dele

O SAP Business Technology Platform oferece um runtime Python (baseado em Cloud Foundry) onde você implanta aplicativos Python como microsserviços. O BTP Python é necessário em cenários específicos: quando seu modelo de ML precisa fornecer previsões dentro de um aplicativo Fiori em tempo real, quando você deseja usar o SAP AI Core para treinamento e serviço de ML gerenciados, ou quando você precisa se conectar a vários sistemas SAP e quer que o serviço de conectividade do BTP lide com as credenciais centralmente.

O custo é maior. Instâncias de aplicativos Cloud Foundry, serviço de conectividade BTP e capacidade do AI Core são todos medidos. Na prática, espere de R$ 2.500 a R$ 10.000 (ou mais, dependendo do dólar) por mês em escala de produção. A configuração em um ambiente corporativo geralmente leva de 2 a 4 semanas, incluindo aprovações de TI e revisões de segurança.

O caminho prático: comece on-premise para desenvolver suas habilidades e provar o valor de negócio. Uma vez que você tenha um modelo funcionando e o apoio dos stakeholders, migre a camada de serviço para o BTP se a integração Fiori em tempo real for necessária. O código Python é idêntico entre os ambientes. Apenas o alvo de implantação muda.

Engenharia de Prompt para Casos de Uso SAP

A engenharia de prompt é a habilidade mais subestimada no espaço SAP+Python em 2026. Para desenvolvedores ABAP, pense nela como escrever uma especificação de módulo de função que a IA executa. A qualidade da sua especificação determina a qualidade da saída. Prompts vagos produzem saídas vagas. Prompts precisos com esquemas de saída explícitos produzem JSON que você pode analisar e usar.

Caso de Uso: Classificação de Tickets de Suporte SAP

Ambientes SAP corporativos geram centenas de tickets de suporte por semana. A triagem manual deles leva de 2 a 4 horas do tempo de suporte L1 diariamente. Um LLM pode classificar e rotear 95% dos tickets em menos de um segundo com precisão que iguala ou excede a triagem humana L1. Custo via Claude Haiku: aproximadamente R$ 0,0015 por ticket (considerando US$ 1 = R$ 5).

import anthropic
import json
import re

client = anthropic.Anthropic()  # Lê ANTHROPIC_API_KEY do ambiente

PROMPT = (
    "Você é um classificador de tickets de suporte SAP.\n"
    "Classifique o ticket abaixo. Responda apenas com JSON válido.\n\n"
    "CATEGORIAS VÁLIDAS: BASIS, FI, MM, SD, PP, HR, CUSTOM, UNKNOWN\n\n"
    "JSON Requerido:\n"
    '{"category":"...","confidence":0.0,"priority":"LOW|MEDIUM|HIGH|CRITICAL",'
    '"routing_team":"...","issue_summary":"uma frase","draft_response":"2-3 frases"}\n\n'
    "Ticket: {ticket_text}"
)

def classify_ticket(ticket_text: str) -> dict:
    message = client.messages.create(
        model="claude-haiku-4-5",    # Haiku: mais rápido e barato para alto volume
        max_tokens=400,
        messages=[{"role": "user",
                   "content": PROMPT.format(ticket_text=ticket_text)}]
    )
    raw = message.content[0].text
    try