De ABAP a Python: Guia do Programador SAP para a Integração de IA/ML

A Verdade Incómoda que Todo Programador ABAP Precisa de Ouvir

Escrevo ABAP há 12 anos. Pagou a minha hipoteca, financiou dois carros e deu-me uma carreira de que estou genuinamente orgulhoso. Relatórios ALV complexos, BAPIs personalizadas, enhancement spots enterrados nos módulos de logística — construí tudo isso. E digo-te agora, sem outra agenda que a honestidade: se não estás a aprender Python em 2026, estás a construir uma carreira sobre alicerces que se estão a reduzir.

Isto não é uma previsão catastrofista. O SAP não vai a lado nenhum. A base instalada é enorme — mais de 400.000 clientes, biliões de dólares de dados empresariais geridos em sistemas ECC e S/4HANA em todo o mundo. Os programadores ABAP serão necessários durante anos. Mas a forma do que fazemos está a mudar mais rapidamente do que a maioria dos consultores está disposta a admitir. SAP Business AI, Joule, analítica embebida, clean core — cada um destes pilares estratégicos corre sobre Python, não ABAP. O novo SAP está a ser construído numa linguagem que talvez ainda não conheças.

A boa notícia — e esta é a parte que me entusiasma genuinamente — é que os programadores ABAP estão numa posição única para vencer na era da IA/ML. Não apesar do nosso background SAP, mas por causa dele. O problema da maioria das equipas de ciência de dados que constroem integrações SAP é que não percebem o que MARD ou VBRP significam. Não sabem por que é que um período contabilístico importa. Não conseguem distinguir um indicador de débito de um documento de compensação. Tu consegues. Esse conhecimento de domínio vale mais do que qualquer tutorial de NumPy.

Este guia é o que eu queria que alguém me tivesse dado quando comecei a minha transição. É prático, tem código real e respeita o facto de já saberes programar. Não precisas de ser tratado como principiante — precisas de uma ponte.

Por Que os Programadores ABAP Têm uma Vantagem Injusta em IA/ML

Antes de escrever uma única linha de Python, sejamos honestos sobre o que já tens e que falta à maioria dos cientistas de dados por completo.

Entendes os Dados com Profundidade Empresarial

Quando se treina um modelo de machine learning com dados de vendas SAP, alguém tem de decidir que tabelas usar, como tratar entregas parciais, como é um documento de cancelamento e por que razão certos registos devem ser excluídos. Um cientista de dados exterior ao SAP passará meses a descobrir que VBRP-FKIMG é a quantidade efectivamente facturada e que precisas de fazer join através de VBRK para a moeda ao nível do cabeçalho. Tu já sabes isto. Escreveste as instruções SELECT. Depuraste os dados.

Conheces os Processos por Detrás dos Números

Os modelos de IA/ML são inúteis sem engenharia de características, e a engenharia de características requer perceber o que os dados significam. Sabes que uma ordem de compra com entrada de mercadorias mas sem factura é um risco de provisionamento. Sabes que um bloqueio de entrega numa ordem de venda significa coisas diferentes em diferentes sociedades. Esta inteligência contextual é a diferença entre um modelo que pontua bem na validação e um que funciona de verdade em produção.

Já Pensas em Fluxos de Dados

A programação ABAP consiste fundamentalmente em mover dados através de processos empresariais: ler de tabelas de base de dados, transformar tabelas internas, chamar módulos de função, escrever de volta. A ciência de dados em Python segue exactamente o mesmo padrão: extrair dados de uma fonte, transformá-los num DataFrame, passá-los por um modelo, escrever resultados de volta. O modelo mental transfere-se quase directamente.

Tens Confiança Organizacional

Colocar IA/ML em produção num ambiente SAP requer navegar por equipas de Basis, segurança, gestão de transportes e aprovação do negócio. Já fizeste tudo isto antes. Um cientista de dados júnior vindo de fora não tem nada disto. As tuas relações existentes e o teu conhecimento institucional são uma enorme vantagem quando chega o momento de fazer o deployment.

ABAP vs Python: Uma Comparação Honesta

Antes de escolher que linguagem usar para uma determinada tarefa, precisas de uma imagem honesta de ambas. Isto é o que 12 anos de ABAP e vários anos de Python realmente se parecem lado a lado:

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

Configurar o teu Ambiente de Desenvolvimento Python-SAP

Antes de qualquer código, precisas de um ambiente funcional. Esta é a configuração exacta que uso e que recomendo.

Pré-requisitos

• Python 3.11+ (descarrega em python.org — evita a versão da Microsoft Store no Windows)
• SAP NetWeaver RFC SDK 7.50 (descarrega no SAP Software Downloads — precisas de um utilizador S)
• Biblioteca pyrfc (wrapper Python para o RFC SDK)
• Um sistema SAP de desenvolvimento com acesso RFC (pede à equipa de Basis um destino RFC)
• VS Code com a extensão Python (opcional mas muito recomendado)

Passo 1: Criar um Ambiente Virtual

Usa sempre um ambiente virtual. É o equivalente Python de manter limpo o namespace de desenvolvimento — não contaminas a instalação global do Python com bibliotecas específicas do projecto.

# Create a project directory
mkdir sap-python-dev
cd sap-python-dev

# Create a virtual environment
python -m venv venv

# Activate it (Linux/Mac)
source venv/bin/activate

# Activate it (Windows)
venv\Scripts\activate

# Your prompt should now show (venv) prefix

Passo 2: Instalar o SAP RFC SDK

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

# Linux: add the SDK library path to your environment
export SAPNWRFC_HOME=/opt/sap/nwrfcsdk
export LD_LIBRARY_PATH=$SAPNWRFC_HOME/lib:$LD_LIBRARY_PATH

# Or add these permanently to ~/.bashrc

Passo 3: Instalar as Bibliotecas Python

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

Resumo breve do que cada uma faz:

• pyrfc — liga o Python ao SAP via RFC (a ponte principal)
• pandas — a tua nova tabela interna. Os 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 do Claude para integração com LLM (usado no Projecto #3)
• python-dotenv — carrega credenciais de um ficheiro .env, mantém os segredos fora do código

Passo 4: Guardar as tuas Credenciais SAP em Segurança

Cria um ficheiro .env na raiz do projecto. Adiciona-o ao .gitignore imediatamente.

SAP_HOST=your-sap-hostname.company.com
SAP_SYSNR=00
SAP_CLIENT=100
SAP_USER=RFC_USER
SAP_PASSWORD=your-password
SAP_LANG=EN
ANTHROPIC_API_KEY=sk-ant-your-key-here

O teu Primeiro Script Python-SAP: Ler um Mestre de Materiais

Comecemos com algo que conheces completamente em ABAP e replicamo-lo em Python. Vamos ler dados básicos de material usando RFC_READ_TABLE — o primeiro passo de qualquer programador ABAP quando liga ferramentas externas ao SAP.

A Forma 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 Python (usando pyrfc)

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

load_dotenv()

# Establish RFC connection — equivalent to setting up a 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")
)

# Call RFC_READ_TABLE — the universal SAP data extraction function
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
)

# Parse results into a 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 materials retrieved: {len(df)}")

conn.close()

Repara na semelhança estrutural: ligar, definir o que queres, executar, iterar sobre os resultados. Os conceitos são idênticos — só muda a sintaxe. Após uma semana de Python, este padrão torna-se tão natural como respirar para qualquer programador ABAP experiente.

Usar BAPI_MATERIAL_GET_ALL para Dados mais Completos

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 return structured output — access fields directly
general_data = result.get("GENERALDATA", {})
print(f"Material: {general_data.get('MATERIAL')}")
print(f"Type: {general_data.get('MATL_TYPE')}")
print(f"Base Unit: {general_data.get('BASE_UOM')}")

Extracção de Dados para IA: Levar Dados SAP para DataFrames do pandas

O verdadeiro poder começa quando começares a extrair conjuntos de dados maiores para análise. Os DataFrames do pandas são o equivalente Python das tabelas internas ABAP, mas com capacidades integradas de analítica, agrupamento, pivotagem e operações estatísticas que requereriam centenas de linhas de código ABAP.

Mapeamento de Tipos ABAP para Python/pandas

Uma Função de Extracção de Dados de Qualidade Produtiva

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

load_dotenv()

def get_sap_connection():
    """Return a reusable RFC connection."""
    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):
    """
    Extract any SAP transparent table into a pandas DataFrame.

    Args:
        conn: active pyrfc.Connection
        table_name: SAP table name (e.g. 'VBRP')
        fields: list of field names to extract
        where_clauses: list of WHERE clause strings (max 72 chars each!)
        max_rows: row limit (be careful with large tables)

    Returns:
        pandas DataFrame
    """
    options = []
    if where_clauses:
        for clause in where_clauses:
            # SAP RFC_READ_TABLE requires clauses under 72 characters
            if len(clause) > 72:
                raise ValueError(f"WHERE clause too long (>72 chars): {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
    )

    # Get field metadata for accurate parsing
    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 é uma armadilha clássica do SAP que apanha todos os programadores novos no RFC_READ_TABLE. Agora não serás um deles.

Projecto Real de IA/ML #1: Previsão de Procura com scikit-learn

É aqui que o investimento compensa. Vamos construir um modelo de previsão de procura usando dados históricos de vendas do SAP — algo que qualquer ambiente SAP tem mas que poucas organizações utilizam realmente para previsão baseada em ML.

O Problema de Negócio

Um responsável de logística quer saber: para cada material de produto acabado, quantas unidades venderemos no próximo mês? Actualmente isto é feito em Excel ou via planeamento integrado do SAP (que requer consultores de MM/PP e configuração dispendiosa). Vamos construir um modelo Python que lê dados históricos de facturação de VBRP e produz previsões.

Passo 1: Extrair Dados Históricos de Vendas

conn = get_sap_connection()

# Extract billing document line items — VBRP joined with VBRK for dates
# Note: RFC_READ_TABLE can't do JOINs, so we extract separately and merge in pandas
vbrp_df = extract_table_to_df(
    conn,
    table_name="VBRP",
    fields=["VBELN", "MATNR", "FKIMG", "VRKME", "NETWR", "WAERK"],
    where_clauses=["VBTYP = 'M'"],  # M = Invoice (billing document)
    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()

# Merge on billing document number
df = pd.merge(vbrp_df, vbrk_df, on="VBELN", how="inner")

# Type conversions — critical step for ABAP developers new to 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()

# Remove cancellations (negative quantities)
df = df[df["FKIMG"] > 0]

print(f"Extracted {len(df):,} billing line items")
print(df.head())

Passo 2: Engenharia de Características

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

# Aggregate to monthly sales per 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"]

# Focus on one material for demonstration — in production you'd loop or use a model per material
material = "000000000010000001"
mat_df = monthly[monthly["MATNR"] == material].copy()
mat_df = mat_df.sort_values("year_month")

# Convert period to numeric index for regression (month number from start)
mat_df["month_index"] = range(len(mat_df))

# Add seasonal features — month of year matters for many products
mat_df["month_of_year"] = mat_df["year_month"].dt.month
mat_df["quarter"] = mat_df["year_month"].dt.quarter

# One-hot encode month of year (captures seasonality)
month_dummies = pd.get_dummies(mat_df["month_of_year"], prefix="month")
mat_df = pd.concat([mat_df, month_dummies], axis=1)

print(f"Training data: {len(mat_df)} months of history")

Passo 3: Treinar o Modelo de Previsão

# Define features — trend (month_index) + seasonality (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"]

# Train/test split — use last 3 months as holdout (time-respecting split)
X_train, X_test = X.iloc[:-3], X.iloc[-3:]
y_train, y_test = y.iloc[:-3], y.iloc[-3:]

# Train Linear Regression model
model = LinearRegression()
model.fit(X_train, y_train)

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

print(f"Mean Absolute Error: {mae:.0f} units")
print(f"R² Score: {r2:.3f}")

# Forecast next month
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"\nForecast for next month: {forecast:.0f} units")

Num deployment em produção, envolvias isto num script Python agendado que escreve as previsões de volta ao SAP usando uma tabela Z personalizada via BAPI_PRODORD_CREATE ou similar, ou num InfoObject de BW via carga de ficheiro plano. A lógica de previsão fica em Python; os resultados voltam ao SAP onde os planeadores os podem usar.

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

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

Extrair Dados de Lançamento FI

conn = get_sap_connection()

# BKPF: FI document header
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: FI document line items
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()

# Type conversions
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)

# Sign convention: SHKZG='S' is debit, 'H' is credit
bseg_df["signed_amount"] = bseg_df.apply(
    lambda r: r["DMBTR"] if r["SHKZG"] == "S" else -r["DMBTR"], axis=1
)

Engenharia de Características para Detecção de Anomalias

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

# Merge header and line items
df_fi = pd.merge(bseg_df, bkpf_df, on=["BELNR", "GJAHR"], how="left")

# Create features that capture anomalous posting behavior
features_df = pd.DataFrame()

# Feature 1: Absolute amount (unusually large amounts are suspicious)
features_df["abs_amount"] = df_fi["signed_amount"].abs()

# Feature 2: Day of week when document was posted (weekend postings are risky)
features_df["day_of_week"] = df_fi["BUDAT"].dt.dayofweek

# Feature 3: Difference between document date and posting date (large gaps = suspicious)
features_df["date_gap_days"] = (df_fi["BUDAT"] - df_fi["BLDAT"]).dt.days.abs().fillna(0)

# Feature 4: Document type encoded as numeric
le = LabelEncoder()
features_df["doc_type_encoded"] = le.fit_transform(df_fi["BLART"].fillna("XX"))

# Feature 5: Account type (vendor, customer, GL) encoded
features_df["acct_type_encoded"] = le.fit_transform(df_fi["KOART"].fillna("X"))

# Feature 6: Log-transformed amount (reduces impact of extreme outliers on model training)
features_df["log_amount"] = np.log1p(features_df["abs_amount"])

# Drop rows with NaN (documents with missing dates, etc.)
features_clean = features_df.dropna()
print(f"Training on {len(features_clean):,} FI line items")

Treinar e Pontuar o Isolation Forest

from sklearn.preprocessing import StandardScaler

# Scale features — Isolation Forest is not sensitive to scale, but it's good practice
scaler = StandardScaler()
X_scaled = scaler.fit_transform(features_clean)

# Train Isolation Forest
# contamination=0.01 means we expect ~1% of postings to be anomalous
iso_forest = IsolationForest(
    n_estimators=200,
    contamination=0.01,
    random_state=42,
    n_jobs=-1
)
iso_forest.fit(X_scaled)

# Score all documents — lower score = more anomalous
anomaly_scores = iso_forest.decision_function(X_scaled)
predictions = iso_forest.predict(X_scaled)  # -1 = anomaly, 1 = normal

# Add results back to the original DataFrame
results_df = df_fi.loc[features_clean.index].copy()
results_df["anomaly_score"] = anomaly_scores
results_df["is_anomaly"] = predictions == -1

# Report top anomalies for human review
anomalies = results_df[results_df["is_anomaly"]].sort_values("anomaly_score")
print(f"\nFlagged {len(anomalies):,} documents for review ({len(anomalies)/len(results_df)*100:.1f}%)")
print("\nTop 10 most anomalous documents:")
print(anomalies[["BELNR", "GJAHR", "BLART", "signed_amount", "USNAM", "anomaly_score"]].head(10))

O resultado é uma lista ordenada de documentos FI que parecem estatisticamente incomuns em comparação com os padrões históricos de lançamento. Nem todos os documentos sinalizados são fraudulentos — alguns são transacções grandes legítimas ou ajustes de fecho de exercício. Mas o modelo reduz drasticamente a carga de revisão: em vez de auditar 100.000 lançamentos, um auditor revê os 1.000 mais suspeitos. Isso é uma redução de 99% no esforço manual.

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

Este é o que genuinamente surpreende os utilizadores de negócio de cada vez. Pegamos no output de um relatório ABAP padrão — o tipo de tabela críptica cheia de tipos de movimento e chaves de conta que só um consultor de logística consegue ler — e usamos o Claude (o LLM da Anthropic) para o traduzir para linguagem simples que qualquer gestor consegue 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()

# Example: Material movement data from 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()

# Type conversions
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)

# Summarize for the LLM (don't send 10,000 rows — summarize first)
summary = mseg_df.groupby("BWART").agg(
    movement_count=("MBLNR", "count"),
    total_qty=("MENGE", "sum"),
    total_value=("DMBTR", "sum")
).reset_index()

# Convert to a JSON-like string for the prompt
summary_text = summary.to_string(index=False)
print("Movement summary prepared for LLM:")
print(summary_text)

Gerar a Explicação em Linguagem Simples

def explain_sap_report(report_data: str, report_context: str) -> str:
    """
    Send SAP report data to Claude for plain-English explanation.

    Args:
        report_data: The actual data (as formatted string or CSV)
        report_context: Context about what the report shows

    Returns:
        Human-readable explanation from Claude
    """
    prompt = f"""You are an SAP business analyst assistant. A user has run an SAP materials
management report and needs it explained in plain English for a non-technical business audience.

Report context: {report_context}

Report data:
{report_data}

SAP movement type reference:
- 101: Goods receipt for purchase order
- 102: Reversal of goods receipt for purchase order
- 201: Goods issue for cost center
- 261: Goods issue for production order
- 311: Transfer posting plant to plant (in)
- 312: Transfer posting plant to plant (out)

Please provide:
1. A 2-3 sentence executive summary of what this report shows
2. Key observations (what stands out — volumes, values, unusual patterns)
3. Any recommended actions or questions a business owner should ask
4. Plain-English explanation of each movement type present in the data

Write in clear, jargon-free language suitable for a supply chain manager who does not know SAP."""

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

    return message.content[0].text


# Generate the explanation
context = "Material movements at Plant 1000 for fiscal year 2025, showing all goods receipts, issues, and transfers."
explanation = explain_sap_report(summary_text, context)

print("\n" + "="*60)
print("PLAIN-ENGLISH REPORT EXPLANATION")
print("="*60)
print(explanation)

O resultado é um resumo executivo gerado automaticamente de qualquer relatório SAP. Podes envolver isto numa interface web simples usando FastAPI e tê-lo implantado em dias. Os utilizadores de negócio executam uma transacção, clicam em "Explicar este relatório" e obtêm um parágrafo que podem colar directamente num email para a gestão. Este tipo de aumentação com IA é onde o conhecimento ABAP e as competências Python se combinam para criar valor empresarial genuíno e imediato.

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

Aprender Python enquanto manténs a tua carreira SAP não requer deixar o teu emprego nem fazer um bootcamp. Este é o caminho realista que daria a um programador ABAP sénior que começa hoje.

Dias 1–15: Fundamentos Python (Mapeados para ABAP)

• Dia 1-2: Instala Python, VS Code e o teu ambiente virtual. Executa o teu primeiro script. O objectivo é um ambiente funcional, não aprender sintaxe.
• Dia 3-5: Sintaxe básica de Python através da lente ABAP. Variáveis (sem declaração DATA), ciclos (FOR em vez de LOOP AT), funções (o equivalente de FORM/FUNCTION é def). Usa o livro Python Crash Course ou o tutorial oficial do Python — ignora tudo sobre web scraping ou jogos e concentra-te em tipos de dados e funções.
• Dia 6-8: Dicionários e listas. Estes são os teus equivalentes a tabelas internas. Um dicionário Python é uma estrutura única como uma área de trabalho; uma lista de dicionários é uma tabela interna. Este modelo mental irá acelerar tudo o resto.
• Dia 9-12: Fundamentos do pandas. Lê a introdução oficial ao pandas em 10 minutos. Pratica: df.head(), df.describe(), df.groupby(), df.merge(). Estas quatro operações cobrirão 80% do que precisas para trabalho com dados SAP.
• Dia 13-15: Liga Python ao teu sistema SAP de desenvolvimento usando pyrfc. Faz funcionar o script do mestre de materiais deste artigo. Quando funcionar, sentirás a mesma satisfação de quando escreveste a tua primeira instrução SELECT a funcionar em ABAP.

Dias 16–45: Engenharia de Dados SAP

• Dia 16-20: Extrai 3 conjuntos de dados SAP distintos que conheces bem (materiais, clientes, ordens de compra). Constrói DataFrames. Pratica joins, agregações e conversões de tipos. O objectivo é a fluência com os teus próprios dados.
• Dia 21-30: Aprende pandas para limpeza de dados. Os dados SAP reais são desorganizados — entradas duplicadas, espaços finais, formatos de data incorrectos, registos de valor zero que devem ser excluídos. Constrói um pipeline de limpeza reutilizável para dados SAP.
• Dia 31-38: matplotlib e plotly para visualização. Constrói 5 gráficos com dados SAP: tendência de vendas ao longo do tempo, top materiais por receita, análise de tipos de movimento, antiguidade de pagamentos a fornecedores, consumo de material por fábrica. A visualização é onde os utilizadores de negócio vêem o valor pela primeira vez.
• Dia 39-45: Agenda um script Python para correr diariamente via cron (Linux) ou Agendador de Tarefas (Windows). Extrai dados SAP, produz um CSV de resumo, envia-o por email usando o smtplib do Python. Este é o teu primeiro deployment "em produção".

Dias 46–75: Machine Learning sobre Dados SAP

• Dia 46-55: Fundamentos do scikit-learn. Trabalha o guia oficial do utilizador na secção de aprendizagem supervisionada. Concentra-te em: LinearRegression, RandomForestRegressor e o padrão train/test split. Não tentes aprender tudo — aprende o fluxo de trabalho.
• Dia 56-60: Constrói o modelo de previsão de procura deste artigo com os teus próprios dados. Adapta-o para um material ou grupo de materiais relevante na tua organização. Mostra o resultado a alguém do planeamento — o feedback real acelera a aprendizagem mais rapidamente do que qualquer curso.
• Dia 61-68: Constrói o modelo de detecção de anomalias sobre os teus dados FI. Senta-te com a equipa de finanças e revejam juntos os documentos sinalizados. Aprenderás mais sobre o que "anómalo" significa no teu contexto específico numa reunião do que em qualquer tutorial.
• Dia 69-75: Aprende os fundamentos de avaliação de modelos: matriz de confusão, precisão/recall (para classificação), MAE/RMSE (para regressão) e validação cruzada. Não precisas de dominar estatística — precisas de saber como determinar se o teu modelo está a funcionar.

Dias 76–90: Deployment e Posicionamento

• Dia 76-80: Fundamentos do FastAPI. Envolve o teu modelo ML numa API REST simples — um endpoint que aceita um número de material e devolve uma previsão. Isto torna o teu modelo acessível a qualquer pessoa que possa fazer um pedido HTTP, incluindo aplicações Fiori.
• Dia 81-85: Git e GitHub. O controlo de versões é inegociável no desenvolvimento Python. Aprende git init, git add, git commit, git push. Cria uma conta no GitHub e faz push dos teus projectos SAP-Python. Isto torna-se o teu portefólio.
• Dia 86-90: Apresenta o teu modelo de previsão de procura ou de detecção de anomalias a um stakeholder de negócio. Não tem de ser perfeito — tem de ser útil. Um modelo funcional que detecta uma única factura fraudulenta ou melhora um ciclo de planeamento em 10% é 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 plano de 90 dias leva-te ao teu primeiro modelo implantado. Esta é a visão alargada de 12 meses — para onde vais depois de essa base estar sólida, e que marcos indicam que estás no caminho certo para as funções híbridas SAP+Python que pagam ao nível mais alto do mercado.

Duas coisas tornam este roteiro realista que planos semelhantes ignoram. Primeiro, estás a construir coisas reais que utilizadores reais podem ver — não projectos de tutorial. Cada marco acima tem um output visível para um stakeholder de negócio. Segundo, os marcos acumulam: a integração LLM do Mês 4 constrói-se sobre o modelo do Mês 3, que se constrói sobre a engenharia de dados do Mês 2. Não começas do zero cada mês — estás a compor.

Os dados salariais suportam este roteiro. Os programadores ABAP que completam este caminho de 12 meses e conseguem demonstrá-lo com um portefólio GitHub e um deployment real tipicamente entram em funções híbridas que pagam de EUR 120.000 a EUR 145.000 nos mercados da Europa Ocidental, versus EUR 85.000 a EUR 100.000 para perfis equivalentes só ABAP. No mercado americano o diferencial é de $115K-$145K versus $90K-$115K.

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

Falemos de dinheiro e oportunidades, porque é isso que em última análise torna o investimento na aprendizagem compensatório.

A Disparidade Salarial é Real

Em 2026, as plataformas de emprego contam uma história clara. As funções de programador ABAP puro (sem Python, sem IA) na Europa Ocidental pagam €80.000–€105.000 anuais para perfis sénior. Adiciona competências demonstradas em Python e pandas — mesmo sem ML — e esses mesmos perfis saltam para €95.000–€125.000. Adiciona um modelo ML implantado ou dois ao portefólio, e estás a ver €120.000–€160.000 para funções híbridas SAP+IA em consultoras, grandes empresas e partners SAP. No mercado americano, o equivalente é aproximadamente $115K–$195K dependendo da localização e do empregador.

O prémio existe porque a oferta de pessoas que entendem ambos os lados é mínima. Um cientista de dados que não conhece o SAP não consegue construir o que tu construirás depois de ler este artigo. Um programador ABAP que não aprendeu Python está excluído da onda da IA. A intersecção — pessoas que conseguem fazer as duas coisas — é onde a compensação atinge o pico.

Onde Estão a Aparecer Estas Funções

• Partners SAP e Integradores de Sistemas: Accenture, Deloitte, Capgemini, IBM têm práticas dedicadas de SAP+IA. Estas funções são rotuladas como "SAP Data Engineer", "SAP ML Developer" ou "SAP AI Consultant". Pagam tarifas de consultoria e dão exposição a múltiplos clientes.
• SAP SE: O SAP está a construir agressivamente capacidades de Business AI no S/4HANA. Contratam programadores ABAP que conseguem trabalhar com as suas plataformas de analítica embebida e AI Core. Procura no LinkedIn funções de "SAP Business AI".
• Grandes Clientes SAP: Empresas de manufactura, farmacêutica e automóvel que correm ambientes SAP complexos estão a construir equipas de IA internas. Querem pessoas que entendam os processos empresariais codificados nos seus sistemas SAP — não cientistas de dados que precisam de 18 meses para aprender o modelo de dados.
• Startups: Um número crescente de empresas está a construir produtos de analítica com IA sobre dados SAP. Estas startups pagam abaixo das tarifas enterprise mas oferecem equity e a aceleração de aprendizagem mais rápida que encontrarás.

Como te Posicionar

A chave não é apresentares-te como "um programador ABAP que também sabe Python". Essa formulação subvaloriza a combinação. Apresenta-te como "um engenheiro de processos empresariais que consegue construir soluções de IA sobre dados SAP" — porque é isso que realmente és depois de completar este caminho de aprendizagem.

O teu perfil no LinkedIn deve mencionar: os módulos SAP que conheces em profundidade (FI, MM, SD, PP — o que se aplica), Python, pandas, scikit-learn e qualquer modelo ou automação implantados que tenhas construído. Mesmo um projecto pessoal conta. Um repositório GitHub com notebooks de análise de dados SAP é um portefólio que 95% dos programadores ABAP não conseguem produzir, o que te diferencia imediatamente.

Erros Habituais que os Programadores ABAP Cometem ao Aprender Python

Cometi a maioria deles. Tu não tens de o fazer.

Erro 1: Iterar em Vez de Vectorizar

Os programadores ABAP instintivamente escrevem ciclos Python da forma como escreveriam LOOP AT em ABAP. Isto funciona, mas é lento com conjuntos de dados grandes e pouco pythónico. Aprende as operações vectorizadas do pandas cedo. Em vez de:

# ABAP-brain Python (slow, un-Pythonic)
for index, row in df.iterrows():
    if row["BWART"] == "101":
        df.at[index, "movement_desc"] = "Goods Receipt"

Escreve:

# Pythonic vectorized operation (fast, clean)
movement_map = {"101": "Goods Receipt", "102": "GR Reversal", "261": "Goods Issue"}
df["movement_desc"] = df["BWART"].map(movement_map)

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

O RFC_READ_TABLE devolve tudo como strings. Os programadores ABAP que não convertem explicitamente os tipos de dados descobrem que as agregações devolvem 0 ou erros. Converte sempre os campos numéricos com pd.to_numeric() e as datas com pd.to_datetime() imediatamente após a extracção.

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

Em ABAP, fazes SELECT com os dados e mostras-os — não há conceito de overfitting. Em ML, um modelo treinado sem um conjunto de validação adequado pode pontuar perfeitamente nos dados de treino e falhar completamente com dados novos. Usa sempre train_test_split, e para dados SAP de séries temporais, divide sempre cronologicamente (não aleatoriamente).

Erro 4: Tentar Aprender Tudo Antes de Construir Algo

O caminho de aprendizagem ABAP é estruturado — estudas a sintaxe, os tipos de dados, o modelo de objectos. O ecossistema Python é suficientemente vasto para que tentar aprender tudo antes de começar te paralise. Constrói algo real com o que sabes após duas semanas. As lacunas no teu conhecimento tornar-se-ão óbvias e específicas assim que te deparares com um problema real.

Reflexões Finais: A Ponte é Mais Curta do que Pensas

Quando executei o meu primeiro script com pyrfc e vi dados SAP aparecer num DataFrame do pandas, lembro-me de pensar: estes são os mesmos dados que tenho estado a ver durante 12 anos, mas agora consigo realmente fazer coisas com eles. Os dados não tinham mudado. Os problemas empresariais não tinham mudado. Mas as ferramentas que podia aplicar-lhes tinham expandido enormemente.

Já entendes algo que nenhum tutorial de Python consegue ensinar: por que razão os dados no SAP têm o aspecto que têm, o que representam num processo empresarial real e o que as mudanças nesses dados significam para as pessoas que dependem deles. Esse conhecimento é a tua base. O Python é simplesmente um conjunto de ferramentas mais poderosas para construir sobre ela.

O plano de 90 dias deste artigo é alcançável a par de uma carreira ABAP a tempo inteiro. Não precisas de noites e fins de semana — precisas de 30-45 minutos concentrados por dia, de forma consistente. Após três meses, terás código funcional, um portefólio no GitHub e a confiança para começar a posicionar-te para as funções que estão a emergir na intersecção do SAP e da IA.

Os programadores ABAP que prosperarão na próxima década não serão os que abandonaram a sua experiência SAP. Serão os que a mantiveram e adicionaram Python por cima. Essa combinação — conhecimento profundo de processos empresariais mais ferramentas modernas de IA/ML — é genuinamente rara, genuinamente valiosa e está ao alcance de qualquer programador disposto a investir o tempo.

BTP Python Runtime vs. Scripts Python em Local: Qual Deves Usar?

Uma das decisões mais práticas que os programadores ABAP enfrentam ao construir as suas primeiras integrações Python-SAP é onde correr o código. A resposta depende do teu ambiente, da tua postura de segurança e da criticidade da carga de trabalho.

Scripts Python em Local: Começa Aqui

Correr Python num servidor dentro da tua rede significa ligar ao SAP via pyrfc ou uma ligação directa ao HANA a partir de uma VM Linux ou Windows dentro da tua DMZ SAP. Esta abordagem é a mais rápida para começar: sem aprovisionamento de nova infra-estrutura, sem configuração de conta BTP, sem processo de aprovação cloud. Para 80% dos casos de uso que os programadores ABAP constroem nos seus primeiros 12 meses de Python, o Python em local é suficiente e dramaticamente mais rápido de implantar do que qualquer alternativa baseada em cloud.

SAP BTP Python Runtime: Quando Realmente Precisas

O SAP Business Technology Platform oferece um runtime Python (baseado em Cloud Foundry) onde implantáis aplicações Python como microserviços. O BTP Python é necessário em cenários específicos: quando o teu modelo ML precisa de servir previsões dentro de uma aplicação Fiori em tempo real, quando queres usar o SAP AI Core para treino e serving geridos de ML, ou quando precisas de ligar a múltiplos sistemas SAP e queres que o serviço de conectividade do BTP gira as credenciais centralmente.

O caminho prático: constrói em local primeiro para desenvolver competências e demonstrar valor empresarial. Uma vez que tenhas um modelo funcional e o apoio dos stakeholders, migra a camada de serving para o BTP se for necessária integração Fiori em tempo real. O código Python é idêntico entre ambientes. Só o destino de deployment muda.

Engenharia de Prompts LLM para Casos de Uso SAP

A engenharia de prompts é a competência mais subestimada no espaço SAP+Python em 2026. Para programadores ABAP, pensa nisto como escrever uma especificação de módulo de função que a IA executa. A qualidade da tua especificação determina a qualidade do output. Prompts vagos produzem outputs vagos. Prompts precisos com esquemas de output explícitos produzem JSON que consegues parsear e sobre o qual consegues agir.

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

Os ambientes SAP empresariais geram centenas de tickets de suporte por semana. Triá-los manualmente consome de 2 a 4 horas diárias de tempo de suporte L1. Um LLM consegue classificar e encaminhar 95% dos tickets em menos de um segundo com uma precisão que iguala ou supera o triagem humana L1. Custo via Claude Haiku: aproximadamente $0,0003 por ticket.

import anthropic
import json
import re

client = anthropic.Anthropic()  # Reads ANTHROPIC_API_KEY from environment

PROMPT = (
    "You are an SAP support ticket classifier.\n"
    "Classify the ticket below. Respond with valid JSON only.\n\n"
    "VALID CATEGORIES: BASIS, FI, MM, SD, PP, HR, CUSTOM, UNKNOWN\n\n"
    "Required JSON:\n"
    '{"category":"...","confidence":0.0,"priority":"LOW|MEDIUM|HIGH|CRITICAL",'
    '"routing_team":"...","issue_summary":"one sentence","draft_response":"2-3 sentences"}\n\n'
    "Ticket: {ticket_text}"
)

def classify_ticket(ticket_text: str) -> dict:
    message = client.messages.create(
        model="claude-haiku-4-5",    # Haiku: fastest and cheapest for high-volume
        max_tokens=400,
        messages=[{"role": "user",
                   "content": PROMPT.format(ticket_text=ticket_text)}]
    )
    raw = message.content[0].text
    try:
        return json.loads(raw)
    except json.JSONDecodeError:
        match = re.search(r'\{.*\}', raw, re.DOTALL)
        return json.loads(match.group()) if match else {"error": "parse_failed"}

# Example: classify_ticket("Cannot post GR - authorization error on movement type 101 plant 1010")
# Returns: {"category":"MM","priority":"HIGH","routing_team":"MM Functional + BASIS",...}

Caso de Uso: Explicação de Anomalias para Equipas de Finanças

Os modelos de detecção de anomalias ML produzem pontuações que só os cientistas de dados conseguem interpretar. Combinar o output do modelo com um LLM que explica as anomalias em linguagem de negócio converte uma pontuação numérica numa conclusão de auditoria accionável que um controller consegue investigar sem precisar de entender machine learning:

ANOMALY_PROMPT = (
    "You are an SAP financial auditor. An ML model flagged this posting as anomalous.\n"
    "Explain in plain business English (3-4 sentences) why it may be suspicious\n"
    "and what a controller should investigate.\n\n"
    "Vendor: {vendor_name} (created: {vendor_created_date})\n"
    "Amount: {currency} {amount}\n"
    "Posted by {user_id} at {posting_time}\n"
    "Bank account last changed: {bank_changed_date}\n"
    "Days from vendor creation to first invoice: {days_to_invoice}\n"
    "Anomaly score: {score} (-1.0=most anomalous, 0.0=normal)"
)

# Example output for a real flagged transaction:
# "This posting warrants investigation for three specific reasons.
# The vendor was created just 4 days before this invoice, consistent with
# fictitious vendor creation. The bank account was changed 2 days after
# creation and 2 days before payment, the classic account-takeover timeline.
# This posting was made at 11:47 PM on a Friday by a user who makes 94% of
# postings during business hours. The controller should verify vendor legitimacy
# and confirm the bank account change had documented dual approval."

Princípios de Engenharia de Prompts para Contextos SAP

• Especifica o formato de output com um esquema. Inclui a estrutura JSON exacta que esperas no prompt. "Responde apenas com JSON válido" previne o preâmbulo conversacional que quebra os parsers downstream.
• Inclui contexto específico do SAP. Diz ao modelo que módulos estão em âmbito, que moeda é usada, que sociedades importam. Sem contexto, o modelo faz suposições genéricas de empresa.
• Usa exemplos few-shot para tarefas de classificação. Incluir 3 a 5 exemplos correctamente classificados no prompt reduz as taxas de má classificação em 30 a 50% versus prompting zero-shot.
• Restringe o vocabulário de output explicitamente. Se precisas de um de 8 valores de categoria, lista os 8. O output em aberto cria problemas de manutenção quando o modelo devolve um valor que o teu código não trata.
• Testa com os teus próprios casos extremos. Os benchmarks genéricos são irrelevantes. Testa os prompts contra os 20 tickets mais confusos ou os lançamentos mais ambíguos do teu sistema SAP real.

3 Projectos SAP Reais que Podes Construir num Fim de Semana

A teoria acelera a prática, mas a prática é o que cria evidência no portefólio e impacto empresarial. Estes são três projectos concretos alcançáveis em 8 a 12 horas de trabalho concentrado durante um fim de semana. Cada um produz algo implantável, demonstrável e imediatamente útil para uma equipa SAP real.

Projecto de Fim de Semana 1: Verificador de Completude do Mestre de Fornecedores

O problema: Os dados incompletos do mestre de fornecedores causam falhas de pagamento, atrasos e acumulação de correcções manuais. A maioria dos ambientes SAP tem milhares de fornecedores com mestres parcialmente preenchidos que ninguém auditou sistematicamente. Um script Python muda essa equação.

O que construís: Um script que extrai todos os fornecedores criados nos últimos 12 meses de LFA1, pontua-os em 15 critérios de completude (dados bancários presentes, número fiscal preenchido, condições de pagamento atribuídas, formato IBAN válido, detecção de conta bancária duplicada) e exporta um ficheiro Excel de remediação ordenado por prioridade segundo pontuação de risco.

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

load_dotenv()

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")
)

result = conn.call("RFC_READ_TABLE",
    QUERY_TABLE="LFA1",
    DELIMITER="|",
    FIELDS=[{"FIELDNAME": f} for f in ["LIFNR", "NAME1", "LAND1", "STCEG", "KTOKK", "ERDAT"]],
    OPTIONS=[{"TEXT": "ERDAT >= '20250101'"}]
)

rows = [e["WA"].split("|") for e in result["DATA"]]
df = pd.DataFrame(rows, columns=["LIFNR", "NAME1", "LAND1", "STCEG", "KTOKK", "ERDAT"])

# Completeness scoring (0-100 scale)
df["score"] = 60
df["score"] += (df["STCEG"].str.strip() != "").astype(int) * 20   # Tax number present
df["score"] += (df["KTOKK"].str.strip() != "").astype(int) * 20   # Account group set

df_remediation = df.sort_values("score").head(200)
df_remediation.to_excel("/tmp/vendor_completeness_report.xlsx", index=False)
print(f"Exported {len(df_remediation)} vendors requiring attention")
print(f"Worst score: {df_remediation['score'].min()}")
conn.close()

Tempo estimado: 8 horas no total. Impacto empresarial: Um cliente encontrou 12 fornecedores com números de conta bancária duplicados — um risco de fraude em pagamentos não detectado durante 3 anos.

Projecto de Fim de Semana 2: Relatório de Antiguidade de Ordens de Compra Vencidas com Alertas por Email

O problema: Os compradores perdem o rasto das posições de ordem de compra onde a entrega está vencida mas não ocorreu a entrada de mercadorias. Estas posições inflacionam os valores de compromisso, distorcem a disponibilidade para promessa e desencadeiam execuções MRP incorrectas.

O que construís: Um script Python que extrai todas as posições de OC abertas com data de entrega vencida de EKPO, categoriza-as por tramos de antiguidade (0-30, 31-60, 61-90, 90+ dias de atraso) e envia um email HTML formatado a cada grupo de compras com os seus itens específicos ordenados por dias de atraso, mais um deep-link Fiori a cada OC.

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

load_dotenv()
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")
)

result = conn.call("RFC_READ_TABLE",
    QUERY_TABLE="EKPO",
    DELIMITER="|",
    FIELDS=[{"FIELDNAME": f} for f in ["EBELN", "EBELP", "MATNR", "MENGE", "EINDT", "EKGRP"]],
    OPTIONS=[
        {"TEXT": "LOEKZ = ' '"},
        {"TEXT": "AND EINDT < '{}'".format(date.today().strftime('%Y%m%d'))},
        {"TEXT": "AND ELIKZ = ' '"}    # Not delivery-complete
    ]
)

rows = [e["WA"].split("|") for e in result["DATA"]]
df = pd.DataFrame(rows, columns=["EBELN", "EBELP", "MATNR", "MENGE", "EINDT", "EKGRP"])
df["EINDT"] = pd.to_datetime(df["EINDT"], format="%Y%m%d", errors="coerce")
df = df.dropna(subset=["EINDT"])
df["days_overdue"] = (pd.Timestamp.today() - df["EINDT"]).dt.days

for ekgrp, group in df.groupby("EKGRP"):
    critical = len(group[group["days_overdue"] >= 90])
    print(f"Group {ekgrp}: {len(group)} overdue PO lines | {critical} CRITICAL (90+ days)")
    # Connect SMTP here for the full email version

conn.close()

Tempo estimado: 8 a 10 horas incluindo formatação de email HTML e configuração SMTP. Impacto empresarial: Num cliente, este relatório reduziu o acumulado de OC vencidas abertas de 4.200 para 890 posições em 60 dias.

Projecto de Fim de Semana 3: API REST de Auto-Classificação de Tickets SAP

O problema: A triagem de suporte SAP L1 consome de 2 a 3 horas por dia de tempo de equipa qualificada em puro reconhecimento de padrões: ler ticket, categorizar, encaminhar. É um alvo textbook de automação com LLM.

O que construís: Um serviço FastAPI que aceita texto de ticket via HTTP POST, classifica-o usando o Claude Haiku e devolve JSON estruturado com categoria, prioridade, equipa de encaminhamento e um rascunho de primeira resposta. Liga-o ao webhook de entrada do teu sistema de tickets e a triagem L1 fica automatizada.

from fastapi import FastAPI
from pydantic import BaseModel
import anthropic, json, re

app = FastAPI(title="SAP Ticket Classifier")
client = anthropic.Anthropic()

PROMPT = (
    "You are an SAP support ticket classifier. Classify the ticket below.\n"
    "Respond with valid JSON only. Required fields: category "
    "(BASIS/FI/MM/SD/PP/HR/CUSTOM/UNKNOWN), priority (LOW/MEDIUM/HIGH/CRITICAL), "
    "confidence (0.0-1.0), routing_team, issue_summary (one sentence), "
    "draft_response (2-3 sentences).\n\nTicket: {text}"
)

class Ticket(BaseModel):
    text: str
    submitted_by: str = ""

@app.post("/classify")
def classify(ticket: Ticket):
    msg = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=400,
        messages=[{"role": "user", "content": PROMPT.format(text=ticket.text)}]
    )
    raw = msg.content[0].text
    try:
        return json.loads(raw)
    except json.JSONDecodeError:
        match = re.search(r'\{.*\}', raw, re.DOTALL)
        return json.loads(match.group()) if match else {"error": "parse_failed"}

# Run: uvicorn ticket_api:app --host 0.0.0.0 --port 8080
# Cost: ~$0.0003 per ticket via Haiku
# ROI: 1,000 tickets/month = $0.30 API cost vs 60+ hours of L1 triage labor

Tempo estimado: 7 horas no total incluindo ajuste de prompts e integração de webhook. Impacto empresarial: Um cliente com 1.200 tickets por mês reduziu o tempo de triagem L1 de 3 horas por dia para menos de 20 minutos. O encaminhamento incorrecto de tickets caiu 78%. Custo mensal total da API: menos de $0,40.

Começa com a instalação do pyrfc. Executa o script do mestre de materiais. O resto vem naturalmente.