De ABAP a Python: Guía para desarrolladores SAP en la integración de IA/ML

La verdad incómoda que todo desarrollador ABAP necesita escuchar

He programado en ABAP durante 12 años. Pagó mi hipoteca, financió dos autos y me dio una carrera de la que estoy genuinamente orgulloso. Informes ALV complejos, BAPIs personalizadas, puntos de mejora (enhancement spots) ocultos en módulos de logística, he construido todo eso. Y te lo digo ahora mismo, sin otra intención que la honestidad: si no estás aprendiendo Python en 2026, estás construyendo una carrera sobre cimientos cada vez más pequeños.

Esto no es una predicción apocalíptica. SAP no va a desaparecer. La base instalada es enorme: más de 400,000 clientes, billones de dólares de datos comerciales gestionados en sistemas ECC y S/4HANA en todo el mundo. Se necesitarán desarrolladores ABAP durante años. Pero la forma de lo que hacemos está cambiando más rápido de lo que la mayoría de los consultores están dispuestos a admitir. SAP Business AI, Joule, analítica integrada, "clean core": cada uno de estos pilares estratégicos se ejecuta en Python, no en ABAP. El nuevo SAP se está construyendo en un lenguaje que quizás aún no conozcas.

La buena noticia, y esta es la parte que realmente me entusiasma, es que los desarrolladores ABAP están en una posición única para triunfar en la era de la IA/ML. No a pesar de nuestra experiencia en SAP, sino gracias a ella. El problema con la mayoría de los equipos de ciencia de datos que construyen integraciones con SAP es que no entienden lo que realmente significan MARD o VBRP. No saben por qué es importante un período contable. No pueden distinguir un indicador de débito de un documento de compensación. Usted sí. Ese conocimiento de dominio vale más que cualquier tutorial de NumPy.

Esta guía es lo que me hubiera gustado que alguien me diera cuando comencé mi transición. Es práctica, tiene código real y respeta el hecho de que usted ya sabe programar. No necesita que lo traten como un principiante, necesita un puente.

Por qué los desarrolladores ABAP tienen una ventaja injusta en IA/ML

Antes de escribir una sola línea de Python, seamos honestos sobre lo que usted ya tiene y que la mayoría de los científicos de datos carecen por completo.

Usted entiende los datos con profundidad de negocio

Cuando un modelo de machine learning se entrena con datos de ventas de SAP, alguien tiene que decidir qué tablas usar, cómo manejar entregas parciales, cómo se ve un documento de anulación y por qué ciertas entradas deben excluirse. Un científico de datos ajeno a SAP pasará meses averiguando que VBRP-FKIMG es la cantidad realmente facturada y que necesita unir a través de VBRK para la moneda a nivel de cabecera. Usted ya lo sabe. Ha escrito las sentencias SELECT. Ha depurado los datos.

Usted conoce los procesos detrás de los números

Los modelos de IA/ML son inútiles sin la ingeniería de características (feature engineering), y la ingeniería de características requiere comprender lo que los datos significan. Usted sabe que una orden de compra con una entrada de mercancías pero sin factura es un riesgo de acumulación. Sabe que un bloqueo de entrega en una orden de venta significa cosas diferentes en diferentes sociedades. Esta inteligencia contextual es la diferencia entre un modelo que puntúa bien en un conjunto de validación y uno que realmente funciona en producción.

Usted ya piensa en flujos de datos

La programación ABAP se trata fundamentalmente de mover datos a través de procesos comerciales: leer de tablas de base de datos, transformar tablas internas, llamar módulos de función, volver a escribir. La ciencia de datos en Python sigue el mismo patrón exacto: extraer datos de una fuente, transformarlos en un DataFrame, ejecutarlos a través de un modelo, volver a escribir los resultados. El modelo mental se transfiere casi directamente.

Usted tiene la confianza organizacional

Poner IA/ML en producción dentro de un entorno SAP requiere navegar por equipos de Basis, seguridad, gestión de transportes y aprobación comercial. Usted ya ha hecho todo esto antes. Un científico de datos junior recién llegado no tiene nada de esto. Sus relaciones existentes y su conocimiento institucional son una enorme ventaja cuando llega el momento de la implementación.

ABAP vs. Python: Una comparación honesta

Antes de elegir qué lenguaje usar para una tarea determinada, necesita una imagen honesta de ambos. Así es como se ven 12 años de ABAP y varios años de Python uno al lado del otro:

La conclusión: estos lenguajes no son competidores. Son socios. ABAP maneja el interior de SAP; Python maneja todo lo que sucede con esos datos fuera de SAP. Los profesionales más valiosos en 2026 conocen ambos.

Configurando su entorno de desarrollo Python-SAP

Antes de cualquier código, necesita un entorno de trabajo. Aquí está la configuración exacta que uso y recomiendo.

Requisitos previos

• Python 3.11+ (descárguelo de python.org — evite la versión de Microsoft Store en Windows)
• SAP NetWeaver RFC SDK 7.50 (descárguelo de SAP Software Downloads — necesita un usuario S)
• Librería pyrfc (wrapper de Python para el RFC SDK)
• Un sistema SAP de desarrollo con acceso RFC (solicite a su equipo de Basis una conexión RFC)
• VS Code con la extensión de Python (opcional pero muy recomendable)

Paso 1: Crear un entorno virtual

Siempre use un entorno virtual. Esto es el equivalente en Python de mantener su espacio de nombres de desarrollo limpio: no contamina la instalación global de Python con librerías específicas del proyecto.

# Crear un directorio de proyecto
mkdir sap-python-dev
cd sap-python-dev

# Crear un entorno virtual
python -m venv venv

# Activarlo (Linux/Mac)
source venv/bin/activate

# Activarlo (Windows)
venv\Scripts\activate

# Su prompt ahora debería mostrar el prefijo (venv)

Paso 2: Instalar el SAP RFC SDK

Descargue nwrfc750P_13-70002755.zip (o la versión más reciente) del Centro de Descargas de Software de SAP. Extráigalo en una ruta conocida; yo uso /opt/sap/nwrfcsdk en Linux o C:\nwrfcsdk en Windows.

# Linux: agregue la ruta de la librería SDK a su entorno
export SAPNWRFC_HOME=/opt/sap/nwrfcsdk
export LD_LIBRARY_PATH=$SAPNWRFC_HOME/lib:$LD_LIBRARY_PATH

# O agregue esto permanentemente a ~/.bashrc

Paso 3: Instalar librerías de Python

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

Breve resumen de lo que hace cada una:

• pyrfc — conecta Python a SAP vía RFC (el puente principal)
• pandas — su nueva tabla interna. Los DataFrames son esenciales para todo lo que sigue
• scikit-learn — la librería estándar de machine learning para datos estructurados/tabulares
• matplotlib — creación de gráficos y visualización
• anthropic — cliente de la API de Claude para integración de LLMs (usado en el Proyecto #3)
• python-dotenv — carga credenciales desde un archivo .env, mantiene los secretos fuera del código

Paso 4: Almacene sus credenciales SAP de forma segura

Cree un archivo .env en la raíz de su proyecto. Agréguelo a .gitignore inmediatamente.

SAP_HOST=su-hostname-sap.empresa.com
SAP_SYSNR=00
SAP_CLIENT=100
SAP_USER=RFC_USER
SAP_PASSWORD=su-contraseña
SAP_LANG=ES
ANTHROPIC_API_KEY=sk-ant-su-clave-aquí

Su primer script Python-SAP: Leyendo un maestro de materiales

Comencemos con algo que usted conoce completamente en ABAP y repliquémoslo en Python. Leeremos datos básicos de materiales usando RFC_READ_TABLE, la primera parada del desarrollador ABAP al conectar herramientas externas a SAP.

La 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.

El equivalente en Python (usando pyrfc)

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

load_dotenv()

# Establecer conexión RFC — equivalente a configurar una conexión RFC de confianza
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", "ES") # Usar español por defecto si no se especifica
)

# Llamar a RFC_READ_TABLE — la función universal de extracción de datos de 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
)

# Parsear resultados en un 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 materiales recuperados: {len(df)}")

conn.close()

Observe la similitud estructural: conectar, definir lo que quiere, ejecutar, recorrer los resultados. Los conceptos son idénticos, solo cambia la sintaxis. Después de una semana con Python, este patrón se vuelve una segunda naturaleza para cualquier desarrollador ABAP experimentado.

Usando BAPI_MATERIAL_GET_ALL para datos más ricos

Para uso en producción, llamar a una BAPI adecuada es más limpio que usar RFC_READ_TABLE:

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

# Las BAPIs devuelven una salida estructurada: acceda a los campos directamente
general_data = result.get("GENERALDATA", {})
print(f"Material: {general_data.get('MATERIAL')}")
print(f"Tipo: {general_data.get('MATL_TYPE')}")
print(f"Unidad base: {general_data.get('BASE_UOM')}")

Extracción de datos para IA: Obtener datos SAP en DataFrames de pandas

El verdadero poder comienza cuando empieza a extraer conjuntos de datos más grandes para análisis. Los DataFrames de pandas son el equivalente en Python de las tablas internas ABAP, pero con capacidades integradas para análisis, agrupación, pivoteo y operaciones estadísticas que requerirían cientos de líneas de código ABAP.

Mapeo de tipos ABAP a Python/pandas

Una función de extracción de datos de grado de producción

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

load_dotenv()

def get_sap_connection():
    """Devuelve una conexión RFC reutilizable."""
    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="ES" # Usar español para las conexiones RFC
    )

def extract_table_to_df(conn, table_name, fields, where_clauses=None, max_rows=50000):
    """
    Extrae cualquier tabla transparente de SAP en un pandas DataFrame.

    Args:
        conn: pyrfc.Connection activa
        table_name: Nombre de la tabla SAP (ej. 'VBRP')
        fields: lista de nombres de campos a extraer
        where_clauses: lista de cadenas de cláusulas WHERE (¡máximo 72 caracteres cada una!)
        max_rows: límite de filas (tenga cuidado con tablas grandes)

    Returns:
        pandas DataFrame
    """
    options = []
    if where_clauses:
        for clause in where_clauses:
            # SAP RFC_READ_TABLE requiere cláusulas de menos de 72 caracteres
            if len(clause) > 72:
                raise ValueError(f"La cláusula WHERE es demasiado larga (>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
    )

    # Obtener metadatos de campo para un parsing preciso
    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)

El límite de 72 caracteres en las cláusulas WHERE es un clásico problema de SAP que confunde a todo desarrollador nuevo en RFC_READ_TABLE. Ahora usted no será uno de ellos.

Proyecto real de IA/ML #1: Pronóstico de demanda con scikit-learn

Aquí es donde la inversión vale la pena. Construiremos un modelo de pronóstico de demanda utilizando datos históricos de ventas de SAP, algo que todo entorno SAP tiene, pero pocas organizaciones realmente utilizan para pronósticos impulsados por ML.

El problema de negocio

Un gerente de logística quiere saber: para cada material de producto terminado, ¿cuántas unidades venderemos el próximo mes? Actualmente, esto se hace en Excel o mediante la planificación integrada de SAP (que requiere consultores de MM/PP y una configuración costosa). Construiremos un modelo de Python que lee datos históricos de facturación de VBRP y produce pronósticos.

Paso 1: Extraer datos históricos de ventas

conn = get_sap_connection()

# Extraer posiciones de documentos de facturación — VBRP unida con VBRK para fechas
# Nota: RFC_READ_TABLE no puede hacer JOINs, así que extraemos por separado y fusionamos en pandas
vbrp_df = extract_table_to_df(
    conn,
    table_name="VBRP",
    fields=["VBELN", "MATNR", "FKIMG", "VRKME", "NETWR", "WAERK"],
    where_clauses=["VBTYP = 'M'"],  # M = Factura (documento de facturación)
    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()

# Fusionar por número de documento de facturación
df = pd.merge(vbrp_df, vbrk_df, on="VBELN", how="inner")

# Conversiones de tipo — paso crítico para desarrolladores ABAP nuevos en 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()

# Eliminar cancelaciones (cantidades negativas)
df = df[df["FKIMG"] > 0]

print(f"Se extrajeron {len(df):,} posiciones de facturación")
print(df.head())

Paso 2: Ingeniería de características (Feature Engineering)

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 por ventas mensuales 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"]

# Enfocarse en un material para demostración — en producción se haría un bucle o se usaría un modelo por material
material = "000000000010000001"
mat_df = monthly[monthly["MATNR"] == material].copy()
mat_df = mat_df.sort_values("year_month")

# Convertir período a índice numérico para regresión (número de mes desde el inicio)
mat_df["month_index"] = range(len(mat_df))

# Agregar características estacionales — el mes del año importa para muchos productos
mat_df["month_of_year"] = mat_df["year_month"].dt.month
mat_df["quarter"] = mat_df["year_month"].dt.quarter

# Codificación one-hot del mes del año (captura la estacionalidad)
month_dummies = pd.get_dummies(mat_df["month_of_year"], prefix="month")
mat_df = pd.concat([mat_df, month_dummies], axis=1)

print(f"Datos de entrenamiento: {len(mat_df)} meses de historial")

Paso 3: Entrenar el modelo de pronóstico

# Definir características — tendencia (month_index) + estacionalidad (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"]

# División de entrenamiento/prueba — usar los últimos 3 meses como conjunto de reserva (división respetando el tiempo)
X_train, X_test = X.iloc[:-3], X.iloc[-3:]
y_train, y_test = y.iloc[:-3], y.iloc[-3:]

# Entrenar el modelo de Regresión Lineal
model = LinearRegression()
model.fit(X_train, y_train)

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

print(f"Error Absoluto Medio: {mae:.0f} unidades")
print(f"Puntuación R²: {r2:.3f}")

# Pronosticar el próximo mes
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"\nPronóstico para el próximo mes: {forecast:.0f} unidades")

En una implementación de producción, esto se envolvería en un script Python programado que escribiría los pronósticos de vuelta a SAP usando una tabla Z personalizada vía BAPI_PRODORD_CREATE o similar, o en un InfoObjeto BW mediante carga de archivo plano. La lógica de pronóstico permanece en Python; los resultados regresan a SAP donde los planificadores pueden usarlos.

Proyecto real de IA/ML #2: Detección de anomalías en documentos FI

El fraude en cuentas por pagar y los errores de contabilización cuestan a las organizaciones millones. La revisión manual es imposible a escala. Isolation Forest, un algoritmo de machine learning no supervisado, se destaca en la búsqueda de documentos que "no se parecen a los demás". Construyámoslo con datos de BKPF/BSEG.

Extraer datos de contabilizaciones financieras

conn = get_sap_connection()

# BKPF: Cabecera de 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: Posiciones de 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()

# Conversiones 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)

# Convención de signo: SHKZG='S' es débito, 'H' es crédito
bseg_df["signed_amount"] = bseg_df.apply(
    lambda r: r["DMBTR"] if r["SHKZG"] == "S" else -r["DMBTR"], axis=1
)

Ingeniería de características para la detección de anomalías

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

# Fusionar cabecera y posiciones
df_fi = pd.merge(bseg_df, bkpf_df, on=["BELNR", "GJAHR"], how="left")

# Crear características que capturen un comportamiento de contabilización anómalo
features_df = pd.DataFrame()

# Característica 1: Cantidad absoluta (cantidades inusualmente grandes son sospechosas)
features_df["abs_amount"] = df_fi["signed_amount"].abs()

# Característica 2: Día de la semana en que se contabilizó el documento (contabilizaciones de fin de semana son riesgosas)
features_df["day_of_week"] = df_fi["BUDAT"].dt.dayofweek

# Característica 3: Diferencia entre la fecha del documento y la fecha de contabilización (grandes desfases = sospechoso)
features_df["date_gap_days"] = (df_fi["BUDAT"] - df_fi["BLDAT"]).dt.days.abs().fillna(0)

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

# Característica 5: Tipo de cuenta (proveedor, cliente, cuenta de mayor) codificado
features_df["acct_type_encoded"] = le.fit_transform(df_fi["KOART"].fillna("X"))

# Característica 6: Cantidad transformada logarítmicamente (reduce el impacto de valores atípicos extremos en el entrenamiento del modelo)
features_df["log_amount"] = np.log1p(features_df["abs_amount"])

# Eliminar filas con NaN (documentos con fechas faltantes, etc.)
features_clean = features_df.dropna()
print(f"Entrenando en {len(features_clean):,} posiciones FI")

Entrenar y puntuar el Isolation Forest

from sklearn.preprocessing import StandardScaler

# Escalar características — Isolation Forest no es sensible a la escala, pero es una buena práctica
scaler = StandardScaler()
X_scaled = scaler.fit_transform(features_clean)

# Entrenar Isolation Forest
# contamination=0.01 significa que esperamos que ~1% de las contabilizaciones sean anómalas
iso_forest = IsolationForest(
    n_estimators=200,
    contamination=0.01,
    random_state=42,
    n_jobs=-1
)
iso_forest.fit(X_scaled)

# Puntuar todos los documentos — puntuación más baja = más anómalo
anomaly_scores = iso_forest.decision_function(X_scaled)
predictions = iso_forest.predict(X_scaled)  # -1 = anomalía, 1 = normal

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

# Reportar las principales anomalías para revisión humana
anomalies = results_df[results_df["is_anomaly"]].sort_values("anomaly_score")
print(f"\nSe marcaron {len(anomalies):,} documentos para revisión ({len(anomalies)/len(results_df)*100:.1f}%)")
print("\nLos 10 documentos más anómalos:")
print(anomalies[["BELNR", "GJAHR", "BLART", "signed_amount", "USNAM", "anomaly_score"]].head(10))

El resultado es una lista clasificada de documentos FI que parecen estadísticamente inusuales en comparación con sus patrones de contabilización históricos. No todos los documentos marcados son fraudulentos; algunos son transacciones grandes legítimas o ajustes de fin de año. Pero el modelo reduce drásticamente la carga de trabajo de revisión: en lugar de auditar 100,000 contabilizaciones, un auditor revisa los 1,000 elementos principales marcados. Eso es una reducción del 99% en el esfuerzo manual.

Proyecto real de IA/ML #3: Descripciones de informes SAP con tecnología LLM

Este es el que realmente sorprende a los usuarios de negocio cada vez. Tomamos la salida de un informe ABAP estándar, el tipo de tabla críptica llena de tipos de movimiento y claves de cuenta que solo un consultor de logística puede leer, y usamos Claude (el LLM de Anthropic) para traducirla a un lenguaje sencillo que cualquier gerente pueda entender.

La configuración

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

Extraer los datos del informe

conn = get_sap_connection()

# Ejemplo: Datos de movimientos de material de 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()

# Conversiones 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 el LLM (no enviar 10,000 filas, resumir primero)
summary = mseg_df.groupby("BWART").agg(
    movement_count=("MBLNR", "count"),
    total_qty=("MENGE", "sum"),
    total_value=("DMBTR", "sum")
).reset_index()

# Convertir a una cadena similar a JSON para el prompt
summary_text = summary.to_string(index=False)
print("Resumen de movimientos preparado para LLM:")
print(summary_text)

Generar la explicación en lenguaje sencillo

def explain_sap_report(report_data: str, report_context: str) -> str:
    """
    Envía datos de un informe SAP a Claude para una explicación en lenguaje sencillo.

    Args:
        report_data: Los datos reales (como cadena formateada o CSV)
        report_context: Contexto sobre lo que muestra el informe

    Returns:
        Explicación legible por humanos de Claude
    """
    prompt = f"""Usted es un asistente de analista de negocio SAP. Un usuario ha ejecutado un informe de gestión de materiales de SAP
y necesita que se lo expliquen en lenguaje sencillo para una audiencia de negocios no técnica.

Contexto del informe: {report_context}

Datos del informe:
{report_data}

Referencia de tipo de movimiento SAP:
- 101: Entrada de mercancías para pedido
- 102: Anulación de entrada de mercancías para pedido
- 201: Salida de mercancías para centro de costos
- 261: Salida de mercancías para orden de producción
- 311: Traslado de stock de planta a planta (entrada)
- 312: Traslado de stock de planta a planta (salida)

Por favor, proporcione:
1. Un resumen ejecutivo de 2-3 oraciones de lo que muestra este informe
2. Observaciones clave (qué destaca: volúmenes, valores, patrones inusuales)
3. Cualquier acción recomendada o preguntas que un propietario de negocio debería hacer
4. Explicación en lenguaje sencillo de cada tipo de movimiento presente en los datos

Escriba en un lenguaje claro y sin jerga, adecuado para un gerente de cadena de suministro que no conoce SAP."""

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

    return message.content[0].text


# Generar la explicación
context = "Movimientos de materiales en la Planta 1000 para el año fiscal 2025, mostrando todas las entradas, salidas y traslados de mercancías."
explanation = explain_sap_report(summary_text, context)

print("\n" + "="*60)
print("EXPLICACIÓN DE INFORME EN LENGUAJE SENCILLO")
print("="*60)
print(explanation)

La salida es un resumen de gestión generado automáticamente de cualquier informe SAP. Puede envolver esto en una interfaz web simple usando FastAPI y desplegarlo en días. Los usuarios de negocios ejecutan una transacción, hacen clic en "Explicar este informe" y obtienen un párrafo que pueden pegar directamente en un correo electrónico de gestión. Este tipo de aumento de IA es donde el conocimiento de ABAP y las habilidades de Python se combinan para crear un valor comercial genuino e inmediato.

La ruta de aprendizaje de 90 días: De cero Python al primer modelo de ML en producción

Aprender Python mientras mantiene su carrera en SAP no requiere dejar su trabajo ni hacer un bootcamp. Aquí está la ruta realista que le daría a un desarrollador ABAP senior que comienza hoy.

Días 1–15: Fundamentos de Python (Mapeado a ABAP)

• Día 1-2: Instale Python, VS Code y su entorno virtual. Ejecute su primer script. El objetivo es un entorno de trabajo, no aprender sintaxis.
• Día 3-5: Conceptos básicos de sintaxis de Python a través de una lente ABAP. Variables (no se necesita declaración DATA), bucles (FOR en lugar de LOOP AT), funciones (el equivalente de FORM/FUNCTION es def). Use el libro Python Crash Course o el tutorial oficial de Python; omita cualquier cosa sobre web scraping o juegos y concéntrese en tipos de datos y funciones.
• Día 6-8: Diccionarios y listas. Estos son sus equivalentes de tablas internas. Un diccionario de Python es una estructura única como un área de trabajo; una lista de diccionarios es una tabla interna. Este modelo mental acelerará todo lo demás.
• Día 9-12: Fundamentos de pandas. Lea la introducción oficial de pandas de 10 minutos. Practique: df.head(), df.describe(), df.groupby(), df.merge(). Estas cuatro operaciones cubrirán el 80% de lo que necesita para el trabajo con datos SAP.
• Día 13-15: Conecte Python a su sistema de desarrollo SAP usando pyrfc. Haga que el script maestro de materiales de este artículo funcione. Cuando funcione, sentirá la misma satisfacción que al escribir su primera sentencia SELECT funcional en ABAP.

Días 16–45: Ingeniería de datos SAP

• Día 16-20: Extraiga 3 conjuntos de datos SAP diferentes que conozca bien (materiales, clientes, órdenes de compra). Construya DataFrames. Practique uniones, agregaciones y conversiones de tipos. El objetivo es la fluidez con sus propios datos.
• Día 21-30: Aprenda pandas para la limpieza de datos. Los datos reales de SAP son desordenados: entradas duplicadas, espacios en blanco al final, formatos de fecha incorrectos, registros con valor cero que deben excluirse. Construya un pipeline de limpieza reutilizable para datos SAP.
• Día 31-38: matplotlib y plotly para visualización. Construya 5 gráficos a partir de datos SAP: tendencia de ventas a lo largo del tiempo, principales materiales por ingresos, desglose por tipo de movimiento, antigüedad de pagos a proveedores, consumo de material por planta. La visualización es donde los usuarios de negocio ven el valor por primera vez.
• Día 39-45: Programe un script de Python para que se ejecute diariamente a través de cron (Linux) o el Programador de Tareas (Windows). Extraiga datos SAP, produzca un CSV de resumen, envíelo por correo electrónico usando smtplib de Python. Este es su primer despliegue "en producción".

Días 46–75: Machine Learning en datos SAP

• Día 46-55: Fundamentos de scikit-learn. Revise la sección de la guía de usuario oficial sobre aprendizaje supervisado. Concéntrese en: LinearRegression, RandomForestRegressor y el patrón de división train/test. No intente aprender todo, aprenda el flujo de trabajo.
• Día 56-60: Construya el modelo de pronóstico de demanda de este artículo con sus propios datos. Ajústelo para un material o grupo de materiales que sea significativo en su organización. Muestre la salida a alguien de planificación; la retroalimentación real acelera el aprendizaje más rápido que cualquier curso.
• Día 61-68: Construya el modelo de detección de anomalías con sus datos FI. Siéntese con el equipo de finanzas y revisen juntos los documentos marcados. Aprenderá más sobre lo que significa "anómalo" en su contexto específico en una reunión que en cualquier tutorial.
• Día 69-75: Aprenda los conceptos básicos de evaluación de modelos: matriz de confusión, precisión/recall (para clasificación), MAE/RMSE (para regresión) y validación cruzada. No necesita dominar las estadísticas, necesita saber cómo saber si su modelo está funcionando.

Días 76–90: Despliegue y posicionamiento

• Día 76-80: Conceptos básicos de FastAPI. Envuelva su modelo de ML en una API REST simple: un endpoint que acepta un número de material y devuelve un pronóstico. Esto hace que su modelo sea accesible para cualquiera que pueda hacer una solicitud HTTP, incluidas las aplicaciones Fiori.
• Día 81-85: Git y GitHub. El control de versiones no es negociable para el desarrollo de Python. Aprenda git init, git add, git commit, git push. Cree una cuenta de GitHub y suba sus proyectos SAP-Python. Esto se convierte en su portafolio.
• Día 86-90: Presente su modelo de pronóstico de demanda o detección de anomalías a un stakeholder de negocio. No tiene que ser perfecto, tiene que ser útil. Un modelo funcional que detecta una factura fraudulenta o mejora un ciclo de planificación en un 10% es una prueba de concepto que abre puertas.

Qué estudiar (recursos específicos)

La hoja de ruta de 12 meses: Del primer script a la IA/ML en producción

La ruta de 90 días anterior en este artículo le lleva a su primer modelo desplegado. Aquí está la vista extendida de 12 meses: a dónde ir después de que esa base sea sólida, y qué hitos indican que está en camino hacia los roles híbridos SAP+Python que pagan en la parte superior del mercado.

Dos cosas hacen que esta hoja de ruta sea realista y que planes similares ignoran. Primero, usted está construyendo cosas reales que los usuarios reales pueden ver, no proyectos de tutoriales. Cada hito anterior tiene una salida visible para un stakeholder de negocio. Esto es importante porque construye su reputación interna y crea la base de evidencia que necesita al posicionarse para mejores roles. Segundo, los hitos se acumulan: la integración de LLM del mes 4 se basa en el modelo del mes 3, que se basa en la ingeniería de datos del mes 2. No está comenzando de nuevo cada mes, está capitalizando.

Los datos salariales respaldan esta línea de tiempo. Los desarrolladores ABAP que completan esta ruta de 12 meses y pueden demostrarlo con un portafolio de GitHub y una implementación en vivo, suelen ingresar a roles híbridos con salarios de USD 120,000 a USD 145,000 en el mercado de Estados Unidos y Latinoamérica, en comparación con USD 90,000 a USD 115,000 para perfiles equivalentes solo de ABAP. Los 12 meses de inversión se amortizan en el primer año del nuevo nivel de compensación.

Implicaciones profesionales: El mercado híbrido SAP+Python en 2026

Hablemos de dinero y oportunidades, porque esto es, en última instancia, lo que hace que la inversión en aprendizaje valga la pena.

La brecha salarial es real

En 2026, las bolsas de trabajo cuentan una historia clara. Los roles de desarrollador ABAP puro (sin Python, sin IA) en Latinoamérica o Estados Unidos, para perfiles senior, ofrecen salarios anuales de USD 80,000 a USD 105,000. Si a esos mismos perfiles se les añaden habilidades demostradas en Python y pandas —incluso sin ML—, los salarios saltan a USD 95,000 a USD 125,000. Si se añade uno o dos modelos de ML desplegados a un portafolio, estamos hablando de USD 120,000 a USD 160,000 para roles híbridos SAP+IA en consultoras, grandes empresas y socios de SAP.

La prima existe porque la oferta de personas que entienden ambas partes es minúscula. Un científico de datos que no conoce SAP no puede construir lo que usted construirá después de leer este artículo. Un desarrollador ABAP que no ha aprendido Python queda excluido de la ola de la IA. La superposición, es decir, las personas que pueden hacer ambas cosas, es donde la compensación alcanza su punto máximo.

Dónde están apareciendo estos roles

• Socios de SAP e Integradores de Sistemas: Accenture, Deloitte, Capgemini, IBM, todos tienen prácticas dedicadas a SAP+IA. Estos roles se etiquetan como "SAP Data Engineer", "SAP ML Developer" o "SAP AI Consultant". Pagan tarifas de consultoría y le brindan exposición a múltiples clientes.
• SAP SE: SAP está construyendo agresivamente capacidades de Business AI en S/4HANA. Contratan desarrolladores ABAP que pueden trabajar con sus plataformas de análisis embebido y AI Core. Busque en LinkedIn roles de "SAP Business AI".
• Grandes clientes de SAP: Las empresas de fabricación, farmacéuticas y automotrices que ejecutan complejos entornos SAP están creando equipos internos de IA. Quieren personas que entiendan los procesos de negocio codificados en sus sistemas SAP, no solo científicos de datos que necesitan 18 meses para aprender el modelo de datos.
• Startups: Un número creciente de empresas están construyendo productos de análisis impulsados por IA sobre datos de SAP (análisis de compras, optimización del capital de trabajo, inteligencia de la cadena de suministro). Estas startups pagan por debajo de las tarifas empresariales, pero ofrecen participación accionaria y la aceleración de aprendizaje más rápida que encontrará en cualquier lugar.

Cómo posicionarse

La clave no es presentarse como "un desarrollador ABAP que también sabe Python". Ese encuadre subestima la combinación. Preséntese como "un ingeniero de procesos de negocio que puede construir soluciones de IA sobre datos SAP", porque eso es lo que realmente será después de completar esta ruta de aprendizaje.

Su perfil de LinkedIn debe mencionar: los módulos de SAP que conoce profundamente (FI, MM, SD, PP, lo que sea aplicable), Python, pandas, scikit-learn, y cualquier modelo o automatización desplegada que haya construido. Incluso un proyecto personal cuenta. Un repositorio de GitHub con notebooks de análisis de datos SAP es un portafolio que el 95% de los desarrolladores ABAP no pueden producir, lo que lo diferencia de inmediato.

La cuestión de la certificación

Las certificaciones importan menos que el código desplegado. Una certificación PCEP de Python Institute indica que aprendió Python. Un repositorio de GitHub con un modelo de pronóstico de demanda de SAP funcionando indica que puede aplicarlo. Priorice lo segundo. Si desea una credencial, SAP Certified Technology Associate — SAP Analytics Cloud es más relevante para el mercado que una certificación genérica de Python, porque demuestra el contexto de SAP junto con la capacidad analítica.

Errores comunes que cometen los desarrolladores ABAP al aprender Python

Yo cometí la mayoría de estos. Usted no tiene por qué hacerlo.

Error 1: Iterar en lugar de vectorizar

Los desarrolladores ABAP escriben instintivamente bucles en Python de la misma manera que escribirían LOOP AT en ABAP. Esto funciona, pero es lento con grandes conjuntos de datos y no es "Pythónico". Aprenda las operaciones vectorizadas de pandas temprano. En lugar de:

# Python con mentalidad ABAP (lento, no Pythónico)
for index, row in df.iterrows():
    if row["BWART"] == "101":
        df.at[index, "movement_desc"] = "Entrada de Mercancías"

Escriba:

# Operación vectorizada Pythónica (rápida, limpia)
movement_map = {"101": "Entrada de Mercancías", "102": "Anulación EM", "261": "Salida de Mercancías"}
df["movement_desc"] = df["BWART"].map(movement_map)

Error 2: Ignorar los tipos de datos después de la extracción

RFC_READ_TABLE devuelve todo como cadenas. Los desarrolladores ABAP que no convierten explícitamente los tipos de datos encuentran que las agregaciones devuelven 0 o errores. Siempre convierta los campos numéricos con pd.to_numeric() y las fechas con pd.to_datetime() inmediatamente después de la extracción.

Error 3: Entrenar con todos los datos disponibles sin validación

En ABAP, se selecciona la data y se muestra; no existe el concepto de sobreajuste (overfitting). En ML, un modelo entrenado sin un conjunto de validación adecuado puede obtener una puntuación perfecta en los datos de entrenamiento y fallar por completo con datos nuevos. Siempre use train_test_split, y para datos de series de tiempo de SAP, siempre divida cronológicamente (no aleatoriamente).

Error 4: Intentar aprender todo antes de construir algo

La ruta de aprendizaje de ABAP está estructurada: se estudia la sintaxis, los tipos de datos, el modelo de objetos. El ecosistema de Python es lo suficientemente vasto como para que intentar aprender todo antes de empezar lo paralice. Construya algo real con lo que sepa después de dos semanas. Las lagunas en su conocimiento se harán obvias y específicas tan pronto como se encuentre con un problema real.

Consideraciones finales: El puente es más corto de lo que cree

Cuando ejecuté mi primer script pyrfc y vi los datos de SAP aparecer en un DataFrame de pandas, recuerdo haber pensado: estos son los mismos datos que he estado viendo durante 12 años, pero ahora realmente puedo hacer cosas con ellos. Los datos no habían cambiado. Los problemas de negocio no habían cambiado. Pero las herramientas que podía aplicar a ellos se habían expandido enormemente.

Usted ya entiende algo que ningún tutorial de Python puede enseñar: por qué los datos en SAP se ven como se ven, qué representan en un proceso de negocio real y qué significan realmente los cambios en esos datos para las personas que dependen de ellos. Ese conocimiento es su base. Python es solo un conjunto de herramientas más potente para construir sobre ella.

La ruta de 90 días de este artículo es alcanzable junto con una carrera ABAP a tiempo completo. No necesita noches y fines de semana; necesita de 30 a 45 minutos concentrados por día, de manera constante. Después de tres meses, tendrá código funcional, un portafolio de GitHub y la confianza para comenzar a posicionarse para los roles que están surgiendo en la intersección de SAP e IA.

Los desarrolladores ABAP que prosperen en la próxima década no serán los que abandonaron su experiencia en SAP. Serán los que la mantuvieron y le agregaron Python. Esa combinación, conocimiento profundo de los procesos de negocio más herramientas modernas de IA/ML, es genuinamente rara, genuinamente valiosa y está disponible para todo desarrollador dispuesto a invertir el tiempo.

Runtime de Python en BTP vs. Scripts Python On-Premise: ¿Cuál debería usar?

Una de las decisiones más prácticas que enfrentan los desarrolladores ABAP al construir sus primeras integraciones Python-SAP es dónde ejecutar el código. La respuesta depende de su entorno, su postura de seguridad y cuán crítica sea la carga de trabajo. Aquí hay una comparación honesta de la implementación de ambos en entornos de producción.

Scripts Python On-Premise: Empiece aquí

Ejecutar Python en un servidor dentro de su red significa conectarse a SAP a través de pyrfc o una conexión HANA directa desde una máquina virtual Linux o un servidor Windows dentro de su DMZ de SAP. Este enfoque es el más rápido para empezar: sin adquisición de nueva infraestructura, sin configuración de cuenta BTP, sin proceso de aprobación en la nube. Instale Python, instale pyrfc, escriba un script, ejecútelo. Un trabajo cron en un servidor Linux que ejecuta extracciones de datos nocturnas, informes semanales y trabajos de puntuación de ML mensuales es confiable, económico y no requiere nuevos contratos con proveedores.

Para entornos aislados en gobierno, defensa o fabricación farmacéutica, el enfoque on-premise suele ser la única opción. Para el 80% de los casos de uso que los desarrolladores ABAP construyen en sus primeros 12 meses de trabajo con Python, el Python on-premise es suficiente y mucho más rápido de implementar que cualquier alternativa basada en la nube.

Runtime de Python en SAP BTP: Cuando realmente lo necesita

SAP Business Technology Platform ofrece un runtime de Python (basado en Cloud Foundry) donde se implementan aplicaciones Python como microservicios. El Python de BTP es necesario en escenarios específicos: cuando su modelo de ML necesita servir predicciones dentro de una aplicación Fiori en tiempo real, cuando desea usar SAP AI Core para la capacitación y el servicio de ML gestionados, o cuando necesita conectarse a múltiples sistemas SAP y desea que el servicio de conectividad de BTP maneje las credenciales de forma centralizada.

El costo es más alto. Las instancias de aplicaciones de Cloud Foundry, el servicio de conectividad de BTP y la capacidad de AI Core se miden. En la práctica, espere de USD 500 a USD 2,000 por mes a escala de producción. La configuración en un entorno empresarial suele tardar de 2 a 4 semanas, incluidas las aprobaciones de TI y las revisiones de seguridad.

El camino práctico: construya on-premise primero para desarrollar sus habilidades y demostrar valor comercial. Una vez que tenga un modelo funcional y la aceptación de los stakeholders, migre la capa de servicio a BTP si se requiere integración Fiori en tiempo real. El código Python es idéntico entre entornos. Solo cambia el objetivo de despliegue.

Ingeniería de Prompts LLM para Casos de Uso SAP

La ingeniería de prompts es la habilidad menos discutida en el espacio SAP+Python en 2026. Para los desarrolladores ABAP, piense en ello como escribir una especificación de módulo de función que la IA ejecuta. La calidad de su especificación determina la calidad de la salida. Los prompts vagos producen resultados vagos. Los prompts precisos con esquemas de salida explícitos producen JSON que puede analizar y sobre el cual puede actuar.

Caso de uso: Clasificación de tickets de soporte SAP

Los entornos SAP empresariales generan cientos de tickets de soporte por semana. La clasificación manual consume de 2 a 4 horas diarias del tiempo de soporte L1. Un LLM puede clasificar y enrutar el 95% de los tickets en menos de un segundo con una precisión que iguala o supera el triaje humano L1. Costo vía Claude Haiku: aproximadamente $0.0003 por ticket.

import anthropic
import json
import re

client = anthropic.Anthropic()  # Lee ANTHROPIC_API_KEY del entorno

PROMPT = (
    "Usted es un clasificador de tickets de soporte SAP.\n"
    "Clasifique el ticket a continuación. Responda solo con JSON válido.\n\n"
    "CATEGORÍAS 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":"una oración","draft_response":"2-3 oraciones"}\n\n'
    "Ticket: {ticket_text}"
)

def classify_ticket(ticket_text: str) -> dict:
    message = client.messages.create(
        model="claude-haiku-4-5",    # Haiku: el más rápido y económico para alto volumen
        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"}

# Ejemplo: classify_ticket("No se puede contabilizar EM - error de autorización en tipo de movimiento 101 planta 1010")
# Retorna: {"category":"MM","priority":"HIGH","routing_team":"Funcional MM + BASIS",...}

Caso de uso: Explicación de anomalías para equipos financieros

Los modelos de detección de anomalías de