SAP Generative AI Hub

from gen_ai_hub.proxy.langchain.openai import ChatOpenAI
from gen_ai_hub.proxy.core.proxy_clients import get_proxy_client

# The SAP AI SDK wraps the Gen AI Hub in LangChain-compatible clients.
# Set AICORE_SERVICE_KEY environment variable to your BTP service key JSON.

proxy_client = get_proxy_client("gen-ai-hub")

# Use GPT-4o via SAP Gen AI Hub
chat_gpt4o = ChatOpenAI(
    proxy_client=proxy_client,
    proxy_model_name="gpt-4o",
    max_tokens=2000,
    temperature=0.3,
)

response = chat_gpt4o.invoke(
    "Summarise the key changes in SAP S/4HANA 2025 OP regarding Clean Core compliance."
)
print(response.content)

# Switch to Claude 3.5 Sonnet with no code changes — just change the model name
chat_claude = ChatOpenAI(
    proxy_client=proxy_client,
    proxy_model_name="claude-3-5-sonnet",
)

# Streaming response
for chunk in chat_claude.stream(
    "Explain SAP Principal Propagation in ABAP Cloud in 3 bullet points."
):
    print(chunk.content, end="", flush=True)

import hdbcli.dbapi as hdb
from gen_ai_hub.proxy.langchain.openai import OpenAIEmbeddings
from gen_ai_hub.proxy.core.proxy_clients import get_proxy_client

# Connect to SAP HANA Cloud
conn = hdb.connect(
    address="<your-hana>.hanacloud.ondemand.com",
    port=443,
    user="DBUSER",
    password="<password>",
    encrypt=True,
)

cursor = conn.cursor()

# Create a table with a REAL_VECTOR column (HANA Vector Engine)
cursor.execute("""
    CREATE COLUMN TABLE SAP_KNOWLEDGE_BASE (
        ID          NVARCHAR(100) PRIMARY KEY,
        CONTENT     NCLOB,
        TOPIC       NVARCHAR(200),
        SOURCE_URL  NVARCHAR(500),
        EMBEDDING   REAL_VECTOR(3072)   -- dimension matches text-embedding-3-large
    )
""")

# Embed and store documents
proxy_client = get_proxy_client("gen-ai-hub")
embedding_model = OpenAIEmbeddings(
    proxy_client=proxy_client,
    proxy_model_name="text-embedding-3-large",
)

documents = [
    {
        "id": "clean-core-001",
        "content": "SAP Clean Core: all extensions must use released APIs. No custom Z-tables in the SAP namespace.",
        "topic": "Clean Core",
        "url": "https://help.sap.com/docs/SAP_S4HANA_ON-PREMISE/2025"
    },
]

for doc in documents:
    vector = embedding_model.embed_query(doc["content"])
    vector_str = "[" + ",".join(str(v) for v in vector) + "]"
    cursor.execute(
        "INSERT INTO SAP_KNOWLEDGE_BASE VALUES (?, ?, ?, ?, TO_REAL_VECTOR(?))",
        (doc["id"], doc["content"], doc["topic"], doc["url"], vector_str)
    )

conn.commit()
print("Documents indexed in HANA Vector Engine")

# Similarity search (cosine distance)
query = "What are the rules for SAP Clean Core extensions?"
query_vector = embedding_model.embed_query(query)
query_vector_str = "[" + ",".join(str(v) for v in query_vector) + "]"

cursor.execute("""
    SELECT TOP 5
        ID, CONTENT, TOPIC,
        COSINE_SIMILARITY(EMBEDDING, TO_REAL_VECTOR(?)) AS SCORE
    FROM SAP_KNOWLEDGE_BASE
    ORDER BY SCORE DESC
""", (query_vector_str,))

results = cursor.fetchall()
for row in results:
    print(f"[{row[3]:.4f}] {row[1][:100]}...")

from gen_ai_hub.orchestration.service import OrchestrationService
from gen_ai_hub.orchestration.models.config import OrchestrationConfig
from gen_ai_hub.orchestration.models.llm import LLM
from gen_ai_hub.orchestration.models.template import Template, TemplateValue
from gen_ai_hub.orchestration.models.message import SystemMessage, UserMessage
from gen_ai_hub.orchestration.models.grounding import (
    GroundingModule,
    DocumentGrounding,
    GroundingFilterSearch,
)
from gen_ai_hub.orchestration.models.content_filter import (
    ContentFilter,
    AzureContentFilter,
)

# Orchestration Service — declarative pipeline with RAG + filtering

# 1. Define the LLM
llm = LLM(
    name="gpt-4o",                   # Gen AI Hub model name
    parameters={"max_tokens": 1000, "temperature": 0.2},
)

# 2. Define the prompt template (Jinja2)
template = Template(
    messages=[
        SystemMessage(
            "You are an SAP expert assistant. Answer ONLY using the provided context. "
            "If the answer is not in the context, say 'I do not have information on this topic.'"
        ),
        UserMessage(
            "Context:\n{{?context}}\n\n"
            "Question: {{?question}}\n\n"
            "Answer in clear, structured bullet points."
        ),
    ]
)

# 3. Configure RAG grounding (HANA Vector Engine)
grounding = GroundingModule(
    type="document_grounding_service",
    config=DocumentGrounding(
        input_params=["question"],
        output_param="context",
        filters=[GroundingFilterSearch(id="vector_search", data_repository_type="vector")],
    ),
)

# 4. Content filtering (Azure AI Content Safety)
content_filter = ContentFilter(
    input=AzureContentFilter(
        Hate=4, Violence=4, SelfHarm=4, Sexual=4
    ),
    output=AzureContentFilter(
        Hate=4, Violence=4, SelfHarm=4, Sexual=4
    ),
)

# 5. Assemble the orchestration config
config = OrchestrationConfig(
    llm=llm,
    template=template,
    grounding=grounding,
    content_filters=content_filter,
)

# 6. Run the orchestration pipeline
service = OrchestrationService(api_url="<orchestration-endpoint-url>", config=config)

result = service.run(
    template_values=[
        TemplateValue(name="question", value="How do I implement a BAdI in ABAP Cloud?"),
    ]
)

print(result.orchestration_result.choices[0].message.content)
# Output: Grounded answer citing retrieved knowledge base chunks

from gen_ai_hub.proxy.core.proxy_clients import get_proxy_client
from gen_ai_hub.proxy.langchain.openai import ChatOpenAI

# Prompt templates are managed in the Gen AI Hub UI and versioned.
# Reference a saved template by its ID and inject runtime variables.

proxy_client = get_proxy_client("gen-ai-hub")
chat = ChatOpenAI(proxy_client=proxy_client, proxy_model_name="gpt-4o")

# Example: PO approval recommendation prompt template (saved in Gen AI Hub)
# Template source (defined in Gen AI Hub UI):
#   "Analyse this purchase order and recommend approve/reject/escalate.
#    PO Number: {{po_number}}
#    Vendor: {{vendor_name}}
#    Amount: {{amount}} {{currency}}
#    Category: {{spend_category}}
#    Requestor: {{requestor_name}}
#    Justification: {{justification}}
#    Respond with: Decision, Risk Level (Low/Medium/High), Reason (max 2 sentences)"

def run_po_approval_template(po_data: dict) -> dict:
    # In production, retrieve the template from Gen AI Hub Prompt Management API
    # and render with the variables. Here shown as a direct implementation.
    prompt = f"""Analyse this purchase order and recommend approve/reject/escalate.
PO Number: {po_data['po_number']}
Vendor: {po_data['vendor_name']}
Amount: {po_data['amount']} {po_data['currency']}
Category: {po_data['spend_category']}
Requestor: {po_data['requestor_name']}
Justification: {po_data['justification']}
Respond with: Decision, Risk Level (Low/Medium/High), Reason (max 2 sentences)"""

    response = chat.invoke(prompt)
    return {"recommendation": response.content, "model": "gpt-4o"}

# Example invocation
result = run_po_approval_template({
    "po_number": "4500012345",
    "vendor_name": "TechSupplies GmbH",
    "amount": "87500",
    "currency": "EUR",
    "spend_category": "IT Hardware",
    "requestor_name": "Jane Doe",
    "justification": "Laptop refresh cycle for Q2 2025 — 50 units Dell Latitude."
})
print(result["recommendation"])

// File: srv/ai-service.cds
service AiService {
  action analyseDocument(
    documentContent : LargeString,
    analysisType    : String(50)   // 'invoice', 'contract', 'purchase-order'
  ) returns {
    analysis   : LargeString;
    model      : String(100);
    tokensUsed : Integer;
  };

  action summariseInvoice(
    invoiceText  : LargeString,
    maxSentences : Integer default 5
  ) returns {
    summary : LargeString;
  };

  action generateEmailDraft(
    decision  : String(20),    // 'approval', 'rejection', 'escalation'
    poNumber  : String(20),
    vendor    : String(100),
    amount    : String(30),
    reason    : LargeString
  ) returns {
    emailDraft : LargeString;
  };
}

### Gen AI Hub — Chat Completions API (OpenAI-compatible)
### Direct REST call — no SDK required

# Obtain a token from BTP UAA (standard OAuth2 client credentials)
TOKEN=$(curl -s -X POST \
  "https://<tenant>.authentication.eu10.hana.ondemand.com/oauth/token" \
  -d "grant_type=client_credentials" \
  -d "client_id=${AICORE_CLIENT_ID}" \
  -d "client_secret=${AICORE_CLIENT_SECRET}" \
  | jq -r '.access_token')

# Chat Completions — GPT-4o via Gen AI Hub
curl -X POST \
  "https://api.ai.prod.eu-central-1.aws.ml.hana.ondemand.com/v2/inference/deployments/<deployment-id>/chat/completions" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "AI-Resource-Group: default" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [
      { "role": "system", "content": "You are an SAP technical expert." },
      { "role": "user",   "content": "Explain the difference between ABAP Cloud Tier 1 and Tier 2." }
    ],
    "max_tokens": 500,
    "temperature": 0.3
  }'

# Embeddings endpoint (for RAG indexing)
curl -X POST \
  ".../v2/inference/deployments/<embedding-deployment-id>/embeddings" \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "AI-Resource-Group: default" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "text-embedding-3-large",
    "input": [
      "SAP Clean Core principles for extensibility",
      "ABAP Cloud released API usage guidelines"
    ]
  }'