SAP AI Core

# Install the SAP AI SDK for Python
pip install sap-ai-sdk

# Or install with all optional extras
pip install "sap-ai-sdk[all]"

from ai_core_sdk.ai_core_v2_client import AICoreV2Client

# Authenticate using BTP service key (set env vars or pass directly)
client = AICoreV2Client(
    base_url="https://api.ai.prod.eu-central-1.aws.ml.hana.ondemand.com/v2",
    auth_url="https://<your-tenant>.authentication.eu10.hana.ondemand.com/oauth/token",
    client_id="<client-id>",
    client_secret="<client-secret>",
)

# Create a Resource Group for isolated tenant workloads
client.resource_groups.create(resource_group_id="production-team-a")

# Register a Git application (GitOps — pipeline templates sync from repo)
from ai_core_sdk.models import ApplicationBaseData

app = client.applications.create(
    application_name="fraud-detection-pipelines",
    repository_url="https://github.com/myorg/ai-core-templates",
    revision="main",
    path="/workflows",
)
print(f"Application synced: {app.application_name}")

# List registered workflow templates (synced from Git)
templates = client.workflow_specs.query(resource_group_id="production-team-a")
for t in templates.resources:
    print(f"  Pipeline: {t.name} — {t.scenario_id}")

# workflows/training-pipeline.yaml
# Stored in Git — AI Core syncs this automatically (GitOps)
apiVersion: argoproj.io/v1alpha1
kind: WorkflowTemplate
metadata:
  name: fraud-detection-training
  annotations:
    scenarios.ai.sap.com/description: "Fraud detection model training pipeline"
    scenarios.ai.sap.com/name: "Fraud Detection"
    executors.ai.sap.com/v1: '[{"name":"fraud-training","image":"<registry>/fraud-trainer:1.0"}]'
    labels.ai.sap.com/version: "1.0.0"
spec:
  templates:
    - name: fraud-detection-training
      inputs:
        parameters:
          - name: learning_rate
            default: "0.001"
          - name: batch_size
            default: "64"
          - name: epochs
            default: "50"
        artifacts:
          - name: training-data
            path: /data/train
      outputs:
        artifacts:
          - name: trained-model
            path: /output/model
            archive:
              none: {}
      container:
        image: "{{workflow.parameters.executors.fraud-training.image}}"
        command: [python, train.py]
        args:
          - "--learning-rate={{inputs.parameters.learning_rate}}"
          - "--batch-size={{inputs.parameters.batch_size}}"
          - "--epochs={{inputs.parameters.epochs}}"
          - "--data-path=/data/train"
          - "--output-path=/output/model"
        resources:
          requests:
            memory: "4Gi"
            cpu: "2"
          limits:
            nvidia.com/gpu: "1"   # Request GPU for training

from ai_core_sdk.models import ExecutionCreationRequest, ParameterBinding

# Trigger a training execution
execution = client.execution.create(
    resource_group_id="production-team-a",
    body=ExecutionCreationRequest(
        configuration_id="fraud-detection-v2-config",
    ),
)
print(f"Execution started: {execution.id} — status: {execution.status}")

# Poll for completion (production use: implement proper event loop / webhook)
import time

while True:
    status = client.execution.get(
        execution_id=execution.id,
        resource_group_id="production-team-a",
    )
    print(f"  Status: {status.status}")
    if status.status in ("COMPLETED", "DEAD", "STOPPED"):
        break
    time.sleep(30)

# Stream execution logs
logs = client.execution.query_logs(
    execution_id=execution.id,
    resource_group_id="production-team-a",
    start="2025-01-01T00:00:00Z",
)
for log in logs.data.result:
    print(f"[{log.timestamp}] {log.msg}")

from ai_core_sdk.models import DeploymentCreationRequest

# Create an inference deployment from a registered model
deployment = client.deployment.create(
    resource_group_id="production-team-a",
    body=DeploymentCreationRequest(
        configuration_id="fraud-detection-serving-config",
    ),
)
print(f"Deployment ID: {deployment.id}")

# Wait for deployment to reach RUNNING state
import time

while True:
    d = client.deployment.get(
        deployment_id=deployment.id,
        resource_group_id="production-team-a",
    )
    print(f"  Deployment status: {d.status}")
    if d.status == "RUNNING":
        print(f"  Inference URL: {d.deployment_url}")
        break
    if d.status in ("DEAD", "STOPPED"):
        raise RuntimeError(f"Deployment failed: {d.status}")
    time.sleep(15)

# Call the inference endpoint
import requests

token = client._get_token()   # Reuse SDK token helper
inference_url = f"{d.deployment_url}/v1/models/fraud-detector:predict"

response = requests.post(
    inference_url,
    headers={
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
        "AI-Resource-Group": "production-team-a",
    },
    json={
        "instances": [
            {"amount": 4500.00, "merchant": "ONLINE_RETAIL", "location": "DE"}
        ]
    },
    timeout=30,
)
print(response.json())
# { "predictions": [{"fraud_probability": 0.03, "label": "LEGITIMATE"}] }

### AI API — REST Examples (curl)
### Base URL: https://api.ai.<region>.ml.hana.ondemand.com/v2

# 1. List resource groups
curl -X GET \
  "https://api.ai.prod.eu-central-1.aws.ml.hana.ondemand.com/v2/admin/resourceGroups" \
  -H "Authorization: Bearer ${AI_CORE_TOKEN}"

# 2. Create a configuration (links a pipeline template to parameter values)
curl -X POST \
  ".../v2/lm/configurations" \
  -H "Authorization: Bearer ${AI_CORE_TOKEN}" \
  -H "AI-Resource-Group: production-team-a" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "fraud-detection-v2-config",
    "executableId": "fraud-detection-training",
    "scenarioId": "fraud-detection-scenario",
    "parameterBindings": [
      { "key": "learning_rate", "value": "0.001" },
      { "key": "batch_size",    "value": "64" },
      { "key": "epochs",        "value": "100" }
    ],
    "inputArtifactBindings": [
      { "key": "training-data", "artifactId": "<dataset-artefact-id>" }
    ]
  }'

# 3. Trigger execution
curl -X POST \
  ".../v2/lm/executions" \
  -H "Authorization: Bearer ${AI_CORE_TOKEN}" \
  -H "AI-Resource-Group: production-team-a" \
  -H "Content-Type: application/json" \
  -d '{ "configurationId": "<config-id>" }'

# 4. Get execution logs
curl -X GET \
  ".../v2/lm/executions/<exec-id>/logs?start=2025-01-01T00:00:00Z" \
  -H "Authorization: Bearer ${AI_CORE_TOKEN}" \
  -H "AI-Resource-Group: production-team-a"

# 5. Create deployment (inference serving)
curl -X POST \
  ".../v2/lm/deployments" \
  -H "Authorization: Bearer ${AI_CORE_TOKEN}" \
  -H "AI-Resource-Group: production-team-a" \
  -H "Content-Type: application/json" \
  -d '{ "configurationId": "<serving-config-id>" }'