Use Cases

How to embed decision flows into webpages and applications using APIs.

• Get access token
• get information about the resources deployed in SAS Viya
• use a decision to score new data.

How to configure Git as a publishing destination in SAS Model Manager.

• Prepare a Git Repository
• Configure Git publishing destination on SAS Viya
• Publish model to Git

Learn how to leverage Python-sasctl to generate metadata and executable scoring model

• Supports automatic score code and metadata generation for many popular Python frameworks
• Register the model into SAS Model Manager, where it can be compared, tested, monitored, and deployed
• Use the import model function to write score code, zip the model files together, and deliver it into Model Manager

Assess model bias, KPI and Hyperparameter integration, and support for automatic score code and metadata generation for TensorFlow Keras models.

• Assess bias for Python models
• Key Performance Indicator (KPI) and Hyperparameter Integration
• TensorFlow Keras

Deploy and score a model using SAS Micro Analytic Service (MAS) via REST APIs.

• Deploy mode into MAS
• Gather model information
• Load and score data

Deploy and score models using SAS Cloud Analytic Services (CAS) for batch via REST APIs.

• Create a CAS destination and publish a model
• Authenticate and start a session
• Load and score data

The python-sasctl package creates a Python interface to SAS Model Manager, where Python users can register a model, create model metadata, write model score code, publish models, and much more.

• Define and execute scoring tests inside SAS Model Manager without leaving their Python notebook.
• Users can create and run scoring tests against any model in their project or just execute existing ones.
• python-sasctl is able to automatically generate scoring code following a simple structure: take input data, load model, send input data through model, process and return output.

This session from SAS Innovate 2025 explores the intersection of theory and practice in AI governance. It demonstrates how organizations can address today’s most pressing AI risks while fostering responsible innovation.

• The importance of ethical considerations in AI development
• How to identify and mitigate key AI risks
• An overview of SAS’s governance solution for AI initiatives

This session from SAS Innovate 2025 explores the full lifecycle of Python machine learning models within the SAS Viya ecosystem.

• Demonstrates how to develop models in SAS Viya Workbench, register them in SAS Model Manager, and document them using model cards
• Discusses responsible AI practices by covering key elements such as model purpose, intended use, limitations, and ethical considerations
• Key components of effective model cards, including ethical considerations

How to organize your SAS projects in Git.

• Organize project repositories in source control for SAS code
• Collaborate with others
• Suggested dos and don'ts of Git

Learn how SAS products integrate with Git.

• Learn how to add source control, code collaboration, and continuous integration and deployment to your SAS processes
• See examples of how SAS experts share their content on GitHub
• Extensive webinar Q&A

Learn about SAS Intelligent Decisioning and how it integrates with Git.

• Integraion advantages
• Integration steps
• What Can You Publish to Git?

How to define a Git publishing destination in SAS Viya.

• Detailed steps to creating the publishing destination on Git
• Required components to creating the publishing destination on Git
• Choose to code in CAS or MAS

Learn about using the SAS Viya Command Line Interface to deploy decisions or rule sets from a Git repository to SAS Viya,

• Deploy from Git
• Make accessible the Git files to the SAS Viya CLI
• Deploy to MAS

Steps to fully integrate Python into a SAS Viya deployment

• Configure persistent storage for ASTORES
• Configure SAS Viya to connect to Python
• Configure CAS for external languages

How to “git” your SAS code projects into Git for version control and collaboration.

• Adding your SAS project to Git (command line)
• Using SAS Enterprise Guide and SAS Studio with Git
• Connecting SAS to your Git accounts and using GIT functions in SAS programming

This use case showcases how to build an intelligent AI assistant that calculates customer risk ratings by integrating SAS Intelligent Decisioning with Azure OpenAI and Azure Logic Apps.

• How to design a conversational AI assistant using Azure OpenAI and SAS Intelligent Decisioning
• How to build and test decision logic in SAS Intelligent Decisioning
• How to publish decision logic as a Docker image to Azure Container Registry (ACR)

This guide walks you through integrating GitHub with SAS Studio in SAS Viya using HTTPS and a Personal Access Token (PAT).

• Why Git is valuable for version control in data and AI projects
• How to generate a Personal Access Token (PAT) in GitHub
• How to securely store your PAT in SAS Viya using Environment Manager

This article provides a high-level overview of how to deploy and score code-wrapped large language models (LLMs) using SAS Agentic AI and Azure cloud services.

• How to deploy code-wrapped LLMs using the SAS Container Runtime (SCR)
• The pros and cons of various Azure deployment options: Azure container instances, Azure container apps, Azure web apps, Kubernetes pods, and containers on virtual machines
• Key considerations for each deployment method: , scalability, ease of setup, security, and resource limits

This article introduces a lightweight MCP (ModelContextProtocol) server designed to score SAS models using a standardized interface compatible with tools like GitHub Copilot.

• What MCP (ModelContextProtocol) is and why it matters for agentic AI
• How to start and configure the viya-scoring-mcp-server using Node.js
• How to integrate the MCP server with GitHub Copilot or other MCP-enabled tools

This session demonstrates how to enhance AI assistant workflows by integrating SAS Intelligent Decisioning with Azure OpenAI.

• How to integrate SAS Intelligent Decisioning with Azure OpenAI
• How Azure Logic Apps connect to SAS decision flows
• How to send user inputs to trusted decision systems and retrieve insights

This session from SAS Innovate explores how developers can use generative AI integrated with SAS Intelligent Decisioning APIs to streamline the creation of decision rules.

• How generative AI can automate rule creation in SAS Intelligent Decisioning
• How real-time validation ensures rule consistency and accuracy
• How to improve collaboration between business and technical teams

This interactive session from SAS Innovate 2025 explores the development and deployment of AI agents using SAS Intelligent Decisioning on SAS Viya.

• How SAS Viya supports the development of agentic AI systems
• The role of human oversight in high-risk AI applications
• Real-world trade-offs in AI decisioning: control vs. speed vs. trust

This use case highlights the importance of using Git for managing data and AI projects in SAS Studio.

• How Git can recover lost or overwritten work in SAS Studio
• Why version control is essential for data and AI workflows
• The benefits of using a managed version control system (e.g., GitHub, GitLab)

This use case explores how data and AI professionals using SAS are adopting Git for version control and collaboration.

• How frequently SAS data and AI users are using Git
• How Git supports sharing and integrating work across teams
• Why Git is essential for collaboration in data and AI projects

This use case explores how to use Azure OpenAI’s GPT-4o to automatically generate custom steps for SAS Studio workflows.

• What the LLM Custom Step Generator is and how it works in SAS Studio
• How to define prompts that describe the logic of a custom step
• How to configure environment variables and system messages for Azure OpenAI and generate custom steps

This use case showcases how to build an AI assistant that not only engages in natural language conversations but also executes real-time, data-driven decisions.

• How to integrate Azure OpenAI Assistants with SAS Intelligent Decisioning
• How conversational AI can trigger backend workflows for real-time decisions
• The role of Azure Logic Apps in connecting user inputs to SAS decision logic

Utilize an LLM to better and more thoroughly explore your SAS Information Catalog data.

• Export your SAS Information Catalog metrics into a CSV file
• Create a LangChain Intelligent Agent utilizing an LLM in Python
• See how using an LLM for your queries can yield different, more nuanced results

Complete your guided tour of configuring GitLab CI/CD Pipelines with SAS Viya by creating a program using GitLab pipelines to execute commands in SAS Viya.

• Pull a docker file from a GitLab registry.
• Configure your GitLab CI/CD pipeline stage, job and script.
• Code your SAS Viya CLI Commands and submit the program to be executed.

Continue your guided tour of configuring GitLab CI/CD pipelines for SAS Viya by creating a customized docker image for your Viya environment.

• Begin by authenticating into the private docker repository you plan on using.
• Create a folder to house the necessary files and copy the necessary SAS Viya certificates into it.
• Craft your Dockerfile and build the image.

Begin a guided tour to configuring GitLab CI/CD pipelines for SAS Viya by registering a GitLab runner.

• Create a GitLab runner and copy its authentication token.
• Utilize a Kubernetes executor to deploy and start the runner.
• Verify that it was registered properly and test the runner.

This use case guides SAS developers and administrators through the necessary steps to transition to authentication domains or SSH keys for Git repository access.

• How to clone a GitHub repository using HTTPS with a Personal Access Token (PAT)
• How to create and configure a Git profile in SAS Studio
• How to securely store Git credentials using SAS Environment Manager

This use case explores how Retrieval Augmented Generation (RAG) can be used to improve the accuracy and relevance of code generation in SAS environments.

• What Retrieval Augmented Generation (RAG) is and how it enhances Large Language Models (LLMs)
• A step-by-step example of generating SAS CAS code using RAG
• The benefits of using RAG for proprietary or less-documented code generation tasks

Learn how to containerize your Python program that uses GenAI to query data using natural language from any table in any SAS library in a SAS Viya environment.

• Convert user questions into SAS code.
• Execute the code in a SAS Viya Compute context.
• Summarize the results in plain language.

Learn how to connect to Git from various SAS platforms.

• Connect to Git via SSH or HTTPs
• Create SSH key for use with SAS and Git
• Using HTTPS and Personal Access Token instead of password

This SAS Quick Start tutorial shows you how to unite the Python language with the power of SAS. You learn how to use the Python SWAT package to take advantage of the SAS Cloud Analytic Services (CAS) engine in SAS Viya for massively parallel processing. See the link below for instructions on how to follow along in your own SAS Viya environment.

• Use the Python SWAT package on SAS Viya
• Explore the available data on the CAS server
• Load data into memory on the CAS server (client side)

This webinar showcases how SAS Viya Workbench addresses common productivity challenges in AI and analytics development.

• How Viya Workbench enables rapid model development with minimal IT overhead
• Ways to avoid unexpected cloud costs using self-terminating, scalable environments
• How to maintain consistent results across teams using different programming languages

This article explores how synthetic data is revolutionizing fraud detection in the banking sector. Traditional fraud detection models often struggle with data scarcity, privacy regulations, and the challenge of capturing rare fraud events.

• Why traditional fraud detection models face limitations in banking environments.
• How synthetic data helps overcome data scarcity and privacy constraints.
• The benefits of using synthetic data, including improved model training, faster development, and secure data sharing.

This article explains how to enhance user experience in SAS Visual Analytics by creating a custom "Reset Filters" button that restores a report to its default state. By leveraging the Reports API and SAS Viya Jobs, developers can automate the deletion of a user's primary report state, ensuring the report reverts to its original, unfiltered configuration.

• How to use the Reports API to manage report states programmatically
• The difference between default, primary, and non-primary report states
• What report states are in SAS Visual Analytics and how they affect user experience

This article showcases how SAS Viya Workbench enables seamless integration of SAS and R within a single environment, allowing users to leverage the strengths of both languages without switching tools or duplicating data.

• How to launch and use SAS Viya Workbench with support for both SAS and R
• Steps to prepare and filter data using a SAS notebook
• How to load and analyze SAS data in an R notebook using the haven package

XML code examples that use SAS Event Stream Processing (ESP) to process real-time streaming data

• Project code is written to run in SAS Event Stream Processing Studio
• Examples are accompanied by READMEs
• Repository is segmented by level of complexity

Transform operational workflows by embedding SAS Visual Analytics dashboards directly into existing applications. Using the SAS Visual Analytics SDK, the integration enables users to access advanced analytics alongside real-time operational data.

• How to embed SAS Visual Analytics dashboards into operational apps
• The role of SAS Visual Analytics SDK and SAS Viya in integration
• How embedded analytics improves user experience and decision-making

firsthand account of adopting SAS Viya Workbench. The presentation walks through the process of setting up the workbench via the AWS Marketplace, customizing the CloudFormation template, and optimizing the environment for real-world use.

• How to access and deploy SAS Viya Workbench through AWS Marketplace
• How SAS and Python can be used together in the cloud environment
• Tips for getting started and maximizing productivity in Viya Workbench

Demonstration of transitioning from an on-premises credit scoring system to a cloud-based solution using SAS Viya on Microsoft Azure, using Python.

• The benefits of using Python with SAS Viya for credit scoring
• How SAS Container Runtime supports scalability and uptime
• Strategies for aligning cloud migration with regulatory and IT policies

This session showcases how SAS Data Maker enables the generation of realistic synthetic data to support analytics and AI development—especially in scenarios where real data is limited, inaccessible, or incomplete.

• How SAS Data Maker generates realistic and useful synthetic data
• The role of synthetic data in modern analytics and AI
• Practical demonstration of SAS Data Maker in action

This session introduces users to SAS Viya Workbench and demonstrates how to configure and begin using the platform, which supports both SAS and Python code through familiar interfaces like Visual Studio Code and Jupyter Notebook.

• How to configure and launch SAS Viya Workbench
• How to use SAS or Python code within the platform
• Integration with Visual Studio Code and Jupyter Notebook

This demo introduces SAS Viya Copilot in Model Studio, a cutting-edge tool that leverages the SAS generative AI platform to enhance the machine learning pipeline development process.

• How SAS Viya Copilot integrates with Model Studio
• The role of generative AI in streamlining analytics
• How to use Viya Copilot as an interactive assistant for pipeline development

This SAS Innovate super demo demonstrates how, using SAS Data Maker, users can generate synthetic data from multiple tables and introduces new data generation methods.

• Techniques for generating synthetic data from multiple tables
• Practical applications of synthetic data in analytics and AI
• How SAS Data Maker has evolved with Hazy integration

This SAS how to tutorial guides you through the essential steps to get started using SAS Viya Workbench, a dynamic self-service platform designed for analytical development, data engineering, and AI and machine learning model building.

• Create a new workbench and select an editor
• View SAS libraries and data
• Work with SAS and Python code

This on-demand webinar from the SAS “Ask the Expert” series is tailored for professionals in life sciences research and analytics. It focuses on how to effectively use the R programming language.

• How to add, explore, visualize, and compute R and .Rdata files in LSAF
• Techniques for ensuring compliance and performance traceability when using R
• Best practices for assessing R packages for accuracy within a validated LSAF environment

This on-demand webinar introduces SAS Viya Workbench for Learners—a free, cloud-based environment designed to help students and educators thrive in a multi-tool data science world.

• Key features and benefits of the SAS Viya Workbench for Learners
• How to manage a data science project using SAS and Python
• Ways to accelerate AI model building using SAS procedures and open-source APIs

This on-demand webinar from the SAS Institute’s “Ask the Expert” series explores how large language models (LLMs) and generative AI (GenAI) can simplify and enhance complex workflows.

• An overview of large language models (LLMs) and generative AI (GenAI) development.
• How to identify and develop LLM-based solutions tailored to your organization’s needs.
• Strategies for integrating LLMs into existing workflows to improve decision-making and operational efficiency.

This on-demand webinar from SAS Institute explores how automated JSON processing can transform clinical programming and data management.

• How to seamlessly automate the conversion of JSON files using SAS
• Ways to enhance data integrity and ensure regulatory compliance.
• Strategies for scalable innovation that drive broader business impact

Explore how organizations can begin realizing returns on their investments in generative AI.

• The current limitations of large language models and how to improve their readability
• How to break down and assess the direct and indirect costs of generative AI.
• A structured approach to evaluating business processes and tasks for LLM suitability

This on-demand webinar from SAS Institute explores how organizations can scale AI development while maintaining governance and data security.

• How SAS Viya Workbench provides a scalable, flexible coding environment for SAS, Python, and R developers.
• Strategies for operationalizing AI models into production environments.
• How SAS Data Maker generates synthetic data that mirrors original datasets while protecting privacy

This blog series by Melodie Rush provides a comprehensive, step-by-step guide to using Python with SAS Viya for predictive modeling

• How to explore and understand your data before modeling.
• How to fit and score various models, including: linear regression, logistic regression, decision trees, random forests, gradient boosting, neural networks, and support vector machines (SVM)
• How to compare model performance using metrics like misclassification rate, ROC curves, and lift charts

This use case demonstrates how to identify and impute missing values in a dataset using the dataPreprocess action set in SAS Viya with Python.

• How to identify variables with missing values using CAS actions
• How to visualize the percentage of missing values using Python and matplotlib
• How to use the dataPreprocess.impute action to fill in missing values

This use case demonstrates how to prepare data for predictive modeling by splitting it into training and validation datasets using Python with SAS Viya.

• Why training and validation datasets are essential for reliable predictive modeling
• How to use the sampling action set in SAS Viya to partition data
• The difference between: simple random sampling (SRS) which is equal chance for all records and stratified sampling which ensures proportional representation of key variables

This use case demonstrates how to build, score, and evaluate a linear regression model using Python with SAS Viya.

• What linear regression is and how it’s used for predictive modeling
• How to load and prepare data in CAS memory using Python
• How to use the SAS Viya regression action set, including: glm for fitting linear models and glmScore for scoring new data

This use case demonstrates how to build, score, and assess a logistic regression model using Python with SAS Viya.

• What logistic regression is and how it applies to binary classification problems
• How to load and prepare modeling data in CAS memory using Python
• How to use the SAS Viya regression action set, specifically: logistic for model training and logisticScore for scoring new data

This use case explores how to compare two predictive modeling techniques—logistic regression and decision trees—using Python integration with SAS Viya.

• How to compare logistic regression and decision tree models using Python in SAS Viya
• How to calculate and interpret: misclassification rate to assess model accuracy., area Under the Curve (AUC) to evaluate classification performance., and lift charts to measure model effectiveness in targeting outcomes
• How to visualize model performance using ROC and lift charts with matplotlib.

This use case demonstrates how to integrate Python with SAS Viya to execute SQL queries on Snowflake using the SWAT (Scripting Wrapper for Analytics Transfer) package.

• How to connect Python to SAS Viya using the SWAT package
• How to configure and authenticate a connection to Snowflake from SAS Viya
• How to create a CASLIB to access Snowflake data

This use case demonstrates how to build, score, and evaluate a Random Forest model using the Python interface to SAS Viya.

• What a Random Forest model is and how it improves prediction accuracy.
• How to load and prepare data in CAS memory using Python and SAS Viya.
• How to use the decisionTree action set to train a Random Forest model.

This use case demonstrates how to build, score, and evaluate a Gradient Boosting model using the SAS Viya platform with Python integration.

• What gradient boosting is and how it improves model accuracy through sequential learning.
• How to load and prepare data in CAS memory using SAS Viya.
• How to use the decisionTree action set to train a gradient boosting model.

This use case explores how organizations can transition from traditional SAS Stored Processes (STPs) in SAS 9.4 to modern SAS Jobs in SAS Viya.

• How to migrate SAS Stored Processes from SAS 9.4 to SAS Viya using tools like createSASPackages and importSASPackages
• How to integrate SAS Jobs into R Shiny applications using direct URL access
• How to configure and execute SAS Jobs via the Viya Job Execution Web Application

This use case walks through the process of building, scoring, and evaluating a neural network model using the SAS Viya SWAT package in Python.

• What neural networks are and how they function in predictive modeling.
• How to load and prepare data in CAS memory using SAS Viya.
• How to use the neuralNet action set to train and score a neural network model.

This use case demonstrates how to build, score, and evaluate a Support Vector Machine (SVM) model using the SWAT package in SAS Viya.

• How to load and prepare data in CAS memory using SAS Viya.

This article introduces the SAS Agentic AI Accelerator, a framework designed to help organizations integrate Generative AI into their workflows using SAS Viya.

• What the SAS Agentic AI Accelerator is and how it supports agentic AI workflows
• How to register code-wrapped LLMs in SAS Model Manager
• Why code wrappers are essential for standardizing model inputs and outputs

This article compares three primary methods for executing SAS jobs in SAS Viya: the SAS Job Execution Web Application, SAS Studio, and the jobExecution REST API.

• SAS Job Execution Web Application: A GUI-based tool for users with minimal coding experience
• SAS Studio: A full-featured coding environment for developers and data scientists
• jobExecution REST API: A programmatic interface for automation and integration

This article explores how to generate synthetic data in SAS Viya using the Python faker library embedded within a SAS Studio Custom Step.

• How to use PROC PYTHON to run Python code within a SAS session
• How to integrate the faker Python package to generate synthetic data
• How to pass SAS macro variables into Python using SAS.symget()

This use case demonstrates how to automate the documentation of SAS Studio flows using a custom step that integrates with Azure OpenAI.

• Why documenting SAS Studio flows is critical for governance and compliance
• How to set up the required components, SAS Viya with Python, Azure OpenAI resource, and .env and system_message.txt configuration files

This article provides a practical guide for SAS developers and analysts on how to convert REST API calls written in cURL into SAS code using PROC HTTP.

• How to navigate the SAS Developer Portal to find relevant API documentation
• How to convert cURL commands into PROC HTTP syntax in SAS
• How to authenticate API calls using sas_services in SAS Studio

This article demonstrates how to build advanced, interactive HTML forms for SAS Viya jobs using the SAS Viya API Wrappers for JavaScript.

• How to use the SAS Viya API Wrappers for JS via CDN in a web page
• How to initialize and manage a ComputeSession to interact with the SAS Compute Server
• How to structure HTML and JavaScript for responsive, user-friendly forms

This article introduces a flexible and developer-friendly approach to integrating SAS Viya Jobs into custom web applications using JavaScript/TypeScript.

• How to build dynamic, custom HTML forms that interact with SAS Viya Jobs
• The limitations of SAS’s built-in JavaScript library and how to overcome them
• How to use the APICall class to authenticate users, handle CSRF tokens, execute REST API calls

This article demonstrates how to use the SAS Viya API Wrappers for JavaScript to create dynamic HTML-based prompts for SAS Viya jobs.

• How to use the SAS Viya API Wrappers for JS via CDN in a web page
• How to initialize a ComputeSession to interact with the SAS Compute Server
• How to dynamically populate HTML <select> elements with libraries, tables, columns, and values

This guide explores how to manage the full lifecycle of analytical models using SAS Model Manager on the SAS Viya platform.

• Create and manage repositories, folders, projects, and model versions
• Import and organize models
• Publish models to scoring destinations

This use case explores how to leverage SAS DATA Step code and macro language to build advanced, customizable scenarios in SAS Visual Investigator.

• The three types of primary scenarios in SAS Visual Investigator
• When and why to use DATA Step scenarios over other types
• How to use predefined macro variables like &INPUT_DATASET, &OUTPUT_DATASET, &MESSAGE, and &SCORE

This use case illustrates how to build a conversational AI assistant that not only interacts naturally with users but also executes complex, rule-based decisions using SAS Intelligent Decisioning.

• How to integrate Azure OpenAI Assistants with SAS Intelligent Decisioning
• How conversational AI can securely collect and process user inputs
• How SAS Intelligent Decisioning calculates risk ratings using rule-based logic

This use case demonstrates how to create a flexible SAS Viya job that allows users to upload multiple data sets through a web form and compare them using the PROC COMPARE procedure.

• How to configure SAS Viya jobs to accept multiple uploaded files
• How to dynamically process multiple uploaded files using macro variable indexing
• How to compare two data sets using PROC COMPARE with an ID statement

This use case demonstrates how to connect SAS software with Microsoft 365 cloud services—such as OneDrive, SharePoint, and Teams—using REST APIs and the PROC HTTP procedure

• How to connect SAS to Microsoft 365 cloud services using REST APIs
• How to use PROC HTTP in SAS to interact with OneDrive, SharePoint, and Teams
• How to register a client app in the Microsoft Azure Portal for authentication

This use case highlights how SAS developers can enhance their productivity by integrating SAS programming directly into Visual Studio Code (VS Code)

• How to install and configure the SAS Extension in VS Code
• How to connect to SAS Viya or SAS 9.4 environments
• Use cases for different user types (developers, students, SAS Studio users)

With Azure OpenAI Assistants function calling, you can ask questions directly from a Jupyter Notebook and translate your queries into SAS code, executes it, and delivers the results back in natural language.

• The Azure OpenAI's Assistant API allows users to analyze data in SAS Viya without writing complex SAS code.
• SASPy, a Python package, facilitates the connection between Python and SAS Viya, enabling seamless data querying and analysis.
• The assistant's true power lies in its ability to convert natural language questions into SAS queries using the function execute_SAS_code.

The sas-viya CLI has a batch plugin that allows SAS programs (which can contain a PROC PYTHON statement to embed Python code) to be submitted from the command line.

• Users can submit Python code or programs for execution in a SAS Compute pod (e.g. in a SAS Studio session)
• The sas-viya CLI has a batch plugin that allows SAS programs (which can contain a PROC PYTHON statement to embed Python code) to be submitted from the command line.
• SAS users can submit Python code for execution in SAS Viya with the PYTHON procedure.

The SWAT code Generator-Executor (GenEx) custom agent approach uses an LLM, GPT-4, to generate Python SWAT code based on user prompts.

• The tool makes large language model (LLM) code generation practical for SAS Viya users.
• Integrate enterprise analytics and data management platforms such as SAS Viya with AI platforms like Azure OpenAI.
• The agent is programmed to interpret the issue and attempt to regenerate the code, aiming for a successful execution.

Use the sendHttp build-in function to query sensor data

• How to format a request
• Bearer token and SOAP examples
• Simple and efficient way to start collecting and processing data

Explore security customizations within Azure DevOps processes with SAS Viya CLI container images.

• Learn how to handle the use and revocation of the Refresh Token.
• Find out how to handle certificates not chained to a public Certificate Authority.
• Fully understand how handling certificates and enhancing security customizations can fortify your pipelines.

Explore security customizations within Azure DevOps processes with SAS Viya CLI container images.

• Learn about Azure Key Vault Security with IP Restrictions.
• Learn how to handle Azure Kubernetes Cluster API IP Restrictions.
• Understand how to handle IP Restrictions for Kubernetes Ingress.

Learn how to use Azure Pipelines to install packages, tools and then pass commands from the SAS Viya CLI.

• Create a virtual machine on Azure
• Configure communication with the SAS Viya Azure Kubernetes Service cluster
• Create an Azure DevOps Self-Hosted agent and install software and packages

Learn how to build interactions between SAS Visual Analytics objects and non-SAS elements when using the SAS Visual Analytics SDK.

• See how SAS Visual Analytics might be deployed on a webpage
• Take a look at VA from a code-level
• Build the connection between SAS Visual Analytics and your web app

Learn how you can use this alternative editor to optimize coding workflow

• Learn how to use the SAS Visual Studio code extension
• Learn about SAS Notebooks
• Explore how the integration can help in your everyday work.

Create a Docker image for a web application integrated with SAS Viya.

• An alternate option to application deployment if a web server is unavailable
• Build your Docker image using a 'Dockerfile'
• Publish your image to an online repository and deploy

Learn how to develop an interactive webpage in Django and Python, utilizing data stored in CAS and altered with SWAT.

• Create a Django web app using Python
• Access CAS data from a Django web app
• Score data using SWAT and display the results

Part 3 in a series on handling data masking in SAS Visual Investigator REST APIs - Learn about the PATCH request.

• See how the PATCH method differs from the PUT method
• Create a PATCH request and verify its results
• Perform more powerful and complex operations with PATCH

Part 2 in a series on handling data masking in SAS Visual Investigator REST APIs - Updating documents with masked data.

• Learn how Datahub processes masked data during PUT requests
• Understand how to use PUT requests to update masked data
• Use a PUT request to clear a masked value from an object

Part 1 in a series on handling data masking in SAS Visual Investigator REST APIs - Examples of and fetching documents with masked data.

• Review REST representations that accommodate masked data
• Explore the process for requesting a REST representation
• Dealing with unmasking one of these representations

Use GenAI to improve your productivity in creating SAS Visual Analytics reports.

• Find a generative AI model that best fits your need and get its API key
• Create a Web Application to handle the connection between the GenAI and Visual Analytics
• Establish the connection in Visual Analytics by assigning the app as Data-Driven-Content

Learn how to download metadata and metrics from SAS Information Catalog for local use.

• Select how rich you would like your uploaded metadata to be, and ensure you have a Viya access token
• Use Python to connect via REST API to retrieve metadata
• Run the program and view your data at different levels of detail

Learn how to upload your metrics from the Information Catalog API to a CAS table.

• Select how rich you would like your uploaded metadata
• Create a Python program that constructs and uses the Catalog API URL to upload your metadata
• Run it in a CLI and view your new table in a CAS library

Learn about the official SAS Extension for Microsoft Visual Studio Code.

• makes it more convenient to use VS Code for programming in the SAS language
• provides SAS language features, including SAS syntax highlighting, color themes, code completion, pop-up syntax help, snippets and the ability to run your SAS code
• efficiently develop SAS programs in VS Code

Learn how to use REST APIs to develop a comprehensive SAS process.

• extracts the tables from the DBMS
• loads them as CAS tables
• demonstrates the ability to integrate SAS® Viya with SAS® 9.4

Learn how web services can be consumed in SAS.

• Explore PROC HTTP
• Generate parameters from existing SAS data
• Process web service output and read it into SAS

Learn how to choose the format that works best for your recipient and explore what you can do with Jupyter notebook cells and markdown functionality.

• Getting started with Jupyter Notebook
• All about Jupyter notebook cells and markdown functionality to enhance text, and more
• How to produce a shareable output of a Jupyter Notebook: PDF, HTML, .sas, etc

Learn how an application can call the SAS Viya promotion APIs to move contents across an environment and promote it to a higher environment.

• use RESTful API to export and import contents
• export and then download content from SAS Viya
• upload and then import content to SAS Viya

How to load, append, and save a table using the SAS Viya Visualization and Core Services REST APIs.

• Create CASlib
• Upload data
• Append table

How to make predictions using a combination of Python and CAS using SWAT.

• Load and analyze data
• Create new features
• Build and scrore models in CAS

How to use a simple application to interact with SAS Viya using REST APIs.

• Create the application
• Create new report if it doesn’t exist
• Generate and execute code

Learn about a repository of code files that compile multiple use cases, available in various coding languages that work with SAS.

• introduces developers to the SAS REST API end-to-end use cases repository on sassoftware GitHub
• Code written in Python, R, and Postman collections
• Authentication code is included for each language.

How to use Python to send commands and controls to the SAS Viya server.

• Python integration with SAS
• Using SWAT
• Create a predictive model

Learn how tokens can be revoked and the implications for any custom clients of SAS Logon Manager.

• Define token types from SAS Logon
• SAS Viya CLI Auto-Refresh
• Revoke tokens

Example of a custom function which can be used to split an incoming string by a user defined delimiter

• Provides a split string funciton not available in Lua
• Example is ESP is provided
• Creating and using modules

Learn about several advanced features of SAS Event Stream Processing (ESP) including stateless joins, tagged tokens, and using the No-regenerates option

• Prevent an Aggregate window from becoming unbounded in growth by keeping the number of values it retains finite
• Create a stateless join to not retain events and greatly improve performance
• Prevent a Join window from re-generating values on the fact side when the dimension side of the join is updated

Learn how to generate, build and deploy a React app using the SASjs CLI.

• bridge the gap between SAS and modern web applications
• manage connection and communication with SAS servers
• create, build and deploy web apps onto SAS servers

Learn about creating a group using the SAS Viya CLI.

• Authenticate to SAS Viya and create a connection
• Create custom user group
• Add permissions

Learn about regions with CNN (R-CNN), used for object detection, and its successors, Fast R-CNN and Faster R-CNN, examples of the application of CNN, and a schematic explanation of processing flows.

• helpful to those wishing to learn more about CNN
• object detection using SAS Viya
• view the program code of Faster R-CNN using SAS Viya

View code snippets for the Transformation windows of SAS Event Stream Processing (ESP).

• includes examples for Aggegate, Compute, Copy, Filter, etc., transform windows
• A directory for each example contains everything you need for execution
• A ocument for each code snippet provides instructions unique to the example

Focus on the integrated process of model managment and analytics deployment.

• Import an Analytics Store (ASTORE) from models built in SAS Model Studio, SAS Studio, or Jupyter Notebook into SAS Model Manager
• Deploy ASTORE from SAS Model Manager in SAS Event Stream Processing Studio
• Focus on the integrated process of model management and analytics deployment

Learn a programmatic way to call a SAS Visual Analytics report to determine how long it takes the report to render using the reportImages service, available via the SAS Viya REST API.

• retrieve the server-side render time of a SAS Visual Analytics report
• Macro code demonstrates how to test a suite of reports for comprehensive A/B comparisons
• determinate the best performance techniques to meet specific reporting needs

Learn how the SASjs framework enables code consistency across teams and projects, de-risks the use of shared tools and dependencies, and facilitates continuous deployment to SAS environments.

• create (scaffold) a SASjs project and add parts
• deploy the jobs to SAS, and run them as part of a flow
• easy authentication to SAS Viya

See how SAS Viya can be used to fulfill reporting and data manipulation requirements of a larger solution.

• define the fundamentals of an ALP system
• explore SAS Viya’s various mechanisms for integration with third party software packages
• embed SAS into larger applications and spread advanced analytics capability

How to connect SAS and Python in a few lines of code using Jupyter Notebooks.

• Demo of how SAS and Python connect using Jupyter Notebooks
• Why combine SAS and Python?
• Build a map of the U.S. spread of COVID-19 using SAS and Python

How to automate Machine Learning pipelines using pre-defined pipelines and custom steps.

• Retrieve a list of available pipeline templates
• Create automation projects for different data segments and check status
• Get the results from an automation project

Learn about CRUD operations for compute contexts from the SAS Viya CLI.

• What are compute context attributes?
• Programmatically create or update a compute context with the desired attributes
• Delete compute context attribute

How to use CAS to surface data and analytical model results to a WebApp through REST API connectivity.

• integrate a scoring model into a custom web application written entirely in Python
• create a web application to capture data
• surface data for real-time decision making

Learn about the setup required to configure SASPy to access SAS Viya from a Jupyter notebook.

• Use Python client to write code for SAS Viya
• Return data in Pandas dataframes
• Install SASPy from sassoftware GitHub

Use the Functional window in SAS Event Stream Processing (ESP) to parse and create event loops over JSON objects.

• Learn Functional window basics
• Parse and process JSON objects
• Use the "Function Context" and "Event Generation" options

See ho restAF provides a simple programming model to access SAS Viya using REST APIs.

• provides a small set of promise-based methods to make the API calls
• simplifies response information for use in the application
• manages the application data that can be accessed anywhere in your application

See how the playbook uses standard Python modules to connect to the SAS Viya REST APIs and is designed with easy to read variable declarations and helper functions.

• Process and prepare data set from a CAS library.
• Run a SAS DATA step to add an indicator variable by calling the RunCode action
• Aggregate the data set

Learn about the matplotlib library and how it integrates with SWAT.

• SWAT utilizes matplotlib entirely in the background, allowing a user to visualize CAS data with a single line of code
• Install SWAT and impot matplotlib
• Examples of creating various plots

Learn about the command-line interface (CLI) in SAS Viya, that can be used to automate several administration tasks.

• How to install the SAS Viya CLI
• How to configure the CLI to communicate with your SAS Viya environment
• How to use the Identities plugin to create a group of users

See how smart meter challenges can be addressed by combining the Deep Learning action set in SAS Visual Data Mining and Machine Learning with the SAS deep learning Python API package, DLPy, and Keras.

• provide a consistent approach both to creating as well as managing and deploying models
• use ONNX for scoring machine learning models
• use SAS and open-source tools together

How to use the REST API and Command-Line Interface (CLI) with SAS Viya to accomplish business tasks with typical scenarios.

• create or edit Visual Analytics (VA) reports programmatically
• localize a VA report based on the standard report
• customize the email content before distributing the reports in batch

How to get started with the REST APIs in SAS Viya.

• Authentication and authorization
• How to construct an API call
• Make the API call and process the results

Create four smaller images or patches out of one larger image using a Lua window and a Calculate window.

• Creating and debugging Lua functions directly in SAS ESP
• Use the calculate window to select the imageProcessing algorithm and the crops function
• View the results in ESP

Learn how SAS Viya REST APIs and workflow tools help to facilitate the model management life cycle.

• introduction to SAS modeling REST APIs
• step through the entire modeling lifecycle using APIs
• automate the modeling lifecycle

Use the Python SWAT package on SAS Viya

• Explore and prepare data
• Visualize and model the data
• Drop tables, delete source files, and terminate the CAS connection

Utilize the the SAS Event Stream Processing (ESP) Transpose window in ESP Studio.

• Use the Transpose Window to transpose table data
• Transpose data from long to wide configuration
• Transpose data from wide to long configuration

Use the SAS Event Stream Processing (ESP) StateDB windows StateDB Reader and StateDB Writer to integrate with Singelstore and Redis in-memory databases.

• Understand SAS Event Stream Processing in Kubernetes
• Introduction to ESP StateDB Windows
• Understand when to use external in-memory databases with ESP

See how to expand the delivery options for data visualizations for reports in SAS Visual Analytics.

• Provide HTML elements allowing navigation of your SAS Viya content from within custom web pages
• Companion content for purpose-built reports to provide ways to deliver information
• Expand the delivery options for data visualizations

Learn about a selection of applications built over these core capabilities, each of which help you obtain answers to questions that motivate you as a business users of AI.

• receive recommendations, gain insight, and make decisions
• expand your understanding of the applicability of text analytics capabilities
• Text analytics packaged within easily deployable and accessible applications

Learn about Viya_Manager, an interface to simplify the administration and management of SAS Viya environments on the Cloud

• Creates a hub to administer deployments of separate SAS Viya environments across different Cloud providers
• Automates the entire deployment cycle by leveraging various deployment tools
• Helps manage installation, infrastructure, and credentials

This project covers the reference architectures for SAS Event Stream Processing (ESP), including the best practices based on project requirements.

• Explore different reference architectures of ESP
• Understand and evaluate which architectures is the best fit for your use-case
• Use a flowchart to helps determinine the right ESP reference architecture that fulfils the business needs

How to update a lookup table using SAS Viya APIs and Proc HTTP.

• Find the lookup table URI and post a new version
• Add lookup table entries to the new version
• Activate the new version

Learn how to train a neural network model with SAS Event Stream Processing (ESP) by capturing bird images.

• Train a neural network model using SAS VDMML to identify birds
• Have SAS ESP process and score images
• Have SAS ESP email us with the bird's picture and predicted species

A functional description with some examples on how to call REST APIs with the REST Subscriber Adapter in SAS Event Stream Processing (ESP).

• Use the REST Adapter Susbscriber to make API calls
• Use the examples as a compliment to SAS documentation
• Use SAS Intelligent Decisioning modeling APIs

Explore the SAS and Python interface and learn about integrating with a machine learning flow.

• Open source package that allows Python users to easily communicate with the SAS Viya platform
• Mlflow is an open source MLOps platform, for managing modeling assets
• Leverage sasctl to generate model metadata and register the model

Learn how to integrate the streaming analytics available with SAS Event Stream Processing (ESP) with Microsoft's Power Automate flows.

• Use MS Azure EventHubs to connect the two computing environments
• Connect using the Kafka adapter using Azure's built-in broker or the native EventHubs connector
• Monitor a sensor and send above-threshold events to generate a maintenance request

The project provides details on the Analytics for IoT reference architecture.

• Introduce the components of Analytics for IoT
• Demo video covering scalable results from IoT data
• Key features of SAS Analytics for IoT

Stream data from an Azure event hub into a SAS Event Stream Processing (ESP) model.

• Use the ESP Kafka connector to connect to an event hub
• Use a function window to transpose a JSON message into ESP events
• Return write data back to the event hub

How to manage the transfer packages created and saved in the Infrastructure Data Server during the import and export of SAS Viya content.

• Export and download transfer package
• Upload and import the transfer package
• Name and view contents of the tranfer package

New window in SAS Event Stream Processing (ESP) allowing developers to process events using Lua language scripting.

• Integrate the powerful analytical Lua scripting language in SAS ESP
• Supports use cases requiring complex transformations using custom functions
• Specify the Lua function entry point in the ESP process

Learn how to integrate ONNX Runtime with SAS Event Stream Processing (ESP) on a Tiny YOLOv2 model, a real-time object detection network.

• Integrate ONNX Runtime with SAS Event Stream Processing
• Leverages an Intel CPU with a CUDA TensorRT CPUb
• Sample UI developed with SAS ESP Connect API

How to translate the examples from your API documentation to their equivalent in SAS.

• Test your API with cURL
• Send data to an API
• Processing JSON responses with the JSON engine

Learn about integrating SAS Visual Analytics content in the SAS portal in Viya.

• Which editor should you use to write my HTML/JavaScript code?
• How do you test your code?
• Do you really need a web server?

Streaming Fraud and Anit-Money Laundering In this tutorial, learn about pattern matching, temporal sliding windows and data aggregation for simple AML / fraud alerts on transactions in a banking use case.

• Simple example set up to scale to larger, faster use cases
• Identify fraud using simple data comparison and analysis with rules
• Take advantage of the SMTP notifications then use a third-party service

Import metadata from a device table and then use this information to enhance the incoming sensor events in SAS Event Stream Processing (ESP)

• Use Lua window to read devices table and store values by key in memory
• Read device events from data source and join events by key
• Filter on events which match device table entriest

Learn how to the store a SAS ESP data stream in a SQLite table using the SAS Micro Analytic Service (MAS).

• Store data in a SQLite table using Python and MAS
• MAS modules are embedded in an ESP project using the and XML tags
• Use the Output statment to configure the how the main function returns variables and values

Learn how to collect live accelerometer data from a mobile device and pass it to ESP using an MQTT protocols with SAS IoT analytics

• Compare new observations against baseline data and any deviation will be considered an anomaly
• Compare new observations against baseline data and any deviation will be considered an anomaly
• Provides ability for machines to self-train their own unique anomaly detection models

Setup the Prometheus monitoring tool for Kubernetes and use the integration with Grafana to query, visualize, alert on, and explore metrics.

• Kubernetes overview
• What to monitor; how to monitor
• SAS Event Stream Processing and Prometheus

Learn how to process messages from an Azure IoT Hub with a SAS Event Stream Processing (ESP) project.

• Configure a simulated IoT Device to send sensor data to an IoT Hub
• Configure the IoT Hub to expose the message stream via an event hub endpoint
• Connect a SAS Event Stream Processing project to process the messages

View code snippets for use in the Utilities window of SAS Event Stream Processing (ESP).

• Includes examples for Pattern and Geofence windows
• A directory for each example contains everything you need for execution
• A document for each code snippet provides instructions unique to the example

Learn how to create and deploy a SAS Event Stream Processing (ESP) high availability (HA) system using Kafka and SAS Viya.

• Learn the basics of the Kafka message bus
• Learn how to deploy an ESP project in failover mode
• How an end to end example

Learn how to access a SAS Viya deployment CAS server from outside its namespace.

• Set the CAS server for external access
• Ability to process binary and HTTP requests
• Access your Viya deployment CAS server(s) from outside

View code snippets for the Analytics windows of SAS Event Stream Processing (ESP).

• Includes examples for Calculate, Train, and Score windows
• A directory for each example contains everything you need for execution
• A document for each code snippet provides instructions unique to the example

This project address four different data quality issues and how to identify them using CAS actions in SAS Viya.

• Covers data completeness, uniqueness, consistency, and accuracy
• Identify quality issues using CAS actions in Viya
• Examples provided are written Python

Expand the capabilities of your Lua windows through the use of modules in SAS Event Stream Processing (ESP)

• A module is a library, loaded using the require statement and containing functions and variables
• Create classes of functions that provide a behavior
• Use a module to move procedural functions or the main code out for re-use or code clarity

Learn how to use the SAS Viya CLI to create Git publishing destinations.

• Create the Git publishing destination
• Publish models and decisions to Git
• From the Git repository, deploy published models or decisions to CAS or MAS

Learn how to train and build a computer vision model for demographic detection using SAS IoT analytics.

• Cover basics of Computer Vision (CV)
• Train CV models using the SAS Deep Learning Python (DLPY) package
• Operationalize our models using streaming analytics

Learn how to stream data from an Azure event hub into a SAS Event Stream Processing (ESP) model using the Azure EventHub Connector.

• Configure an Azure Logic application to query a service
• Format response data and send it to an Azure Event Hub
• Create an ESP project to receive events from the Event Hub using the ESP Azure Event Hub Connector

Retain events and calculate the event throughput rate using SAS Event Stream Processing (ESP).

• Configure event retention on time and volume
• Calculate throughput based on a function
• Use a Copy window to retain events

Provides an index of Getting Started with Python integration to SAS Viya.

• Eight-part series of articles
• Python integration
• CAS Actions

How to use Python and SAS Viya REST APIs to extract a report and import it into another environment.

• Learn about Continuous Integration/Continuous Delivery
• Learn about ModelOps and AnalyticOps
• Apply principals to SAS reports

Learn how to build a model for real-time detection of malfunctioning light groupings using SAS IoT analytics.

• Design streaming model for real-time failure detection
• Use subspace tracking algorithm to detect anomalies
• Best practices for subspace tracking algorithm

A guided use case on how starting with raw data, you can use Viya and open source together to create and deploy models.

• Use open source languages and packages to enable development and deployment of models
• Explore key integration points between Viya and open source
• Learn how open source developers can take advantage of the CAS in-memory engine of Viya to speed model development against large data

Learn how to aggregate stock transactions using SAS Event Stream Processing (ESP).

• Aggregate values, execute an XML model, and subscribe with a file/socket adapter
• Model description, editing, executing, and subscribing
• View, edit, and test model

Explore how Event Stream Processing (ESP) Routers work, along with examples easily extended to more complex use cases.

• Learn the basics about ESP routers
• Use ESP routers for streaming applications into modules
• Learn how to scale applications to add/remove modules, while limiting interruptions

The project provides details on developing and refining reference architecture(s) for SAS integration with Azure IoT, as well as the full set of Azure cloud services.

• Introduce architects to the component Azure services
• Understand common integration patterns
• Authentication considerations

Identify objects (i.e., people) who are following social distancing guidelines and those who are not using SAS IoT analytics.

• Use Tiny Yolo V2 model to detect people in images
• Calculate the distances between all objects
• Determine whether we have crowds in our image

Learn how to programatically list SAS Visual Analytics report paths and filter columns.

• Visualize lineage within SAS Visual Analytics
• Use the REST API to collect report information and content
• Add filters to the API call

Utilize the Database Connector with DataDirect Drivers in SAS Event Stream Processing (ESP) to read and write data to relational databases.

• Use database connector with DataDirect drivers
• Configure the connector using the configuration file e.g. odbc.ini
• Understand the configuration file “odbc.ini” and parameter considerations

How to use the SAS Viya CLI to create model publishing destinations.

• Create a base64 Credentials Domain
• Download the SAS Viya CLI directly from the SAS Support website
• Create an Azure publishing destination

Learn how to build an interactive web page which uses data stored in CAS and the application will be developed in Python using the Dash and SWAT packages

• Use Dash to build the layout of the web application
• Load data into CAS and execute CAS actions to manipulate data on the CAS server
• Query large tables stored into CAS and display the results using your preferred language

Explore various types of SAS Event Stream Processing (ESP) windows and their functions using the Zambretti alorithm for weather forecasting.

• Use the ESP Expression Language to perform calculations
• Filter outliers using Filter windows
• Detect trends using Pattern windows

How to build similar SAS 9 functionalities in the Viya world.

• Understadning SAS Information Delivery Portal
• Understanding SAS Drive
• Building a Portal in SAS Viya

Stream live weather data into any SAS Event Stream Processing (ESP) model.

• Capture live weather data using REST APIs
• Use ESP's URL connector to publish data into a model
• Read and transform JSON messages into events readable by ESP

An image classification example that uses a Rubik's Cube to demonstrate how to apply the the technique in manufacturing quality using SAS IoT analytics.

• Use SAS Analytics for IoT to train and build an image classification model
• Train CV models using the SAS Deep Learning Python (DLPY) package
• Operationalize models using streaming analytics and ESPPy

Lightweight, standalone development environment built for the creation of high-performance models in your preferred language: SAS, Python or R

• Learn about the on-demand computing flexibility
• Watch SAS Viya analytics run in harmony with SAS®9 procedures
• See the newest Python API for SAS analytics inspired by scikit-learn

Learn how to build an anomaly detection model and deploy it for real-time monitoring of malfunctioning Air Handling Units (AHUs) using SAS IoT analytics.

• Build an anomaly detection model using Support Vector Data Description (SVDD) algorithm
• Deploy an offline model for real-time failure detection
• Score the model and interpret the results

Learn how to create and deploy a SAS Event Stream Processing (ESP) high availability system using Kafka as the message broker.

• Examine high availability concepts and the basics of the Kafka message bus
• Deploy ESP in failover models
• Walk through an end to end example

How to modify a landing page to display links to other applications and display some KPI's.

• Create the shortcuts and landing page components
• Build the JSON configuration file
• Update the JavaScript application file

How to access Cloud Analytics Services (CAS) actions using the Python SWAT package inside SAS Studio.

• Exploit the seamless interoperability between Python and CAS runtimes
• Use automation and environment variables available within a SAS Studio session to connect
• Automate connection using AutoExec

Learn how you can use this new editor to optimize coding workflow

• How the integration can help in your everyday work
• Connect to SAS Viya or SAS 9 from the extension and run code
• SAS syntax highlighting and help, code completion, and code snippets

Learn how to process streaming trade data using SAS Event Stream Processing (ESP).

• View and edit a model using a text editor and SAS ESP Studio
• Execute the model using the SAS ESP XML Server
• Subscribe to the output using SAS ESP Streamviewer

In tTracking the International Space Station (ISS) using a Geofences ESP example

• Learn the basics of a geofence
• Create required source windows: source, geoCircle, filter, and pattern
• Create and use GEO maps using ESP Streamviewer

Use SAS DLPy to train and validate a SAS Viya deep learning image denoising model

• Uses the concept of pixel-wise CNN segmentation regression to remove noise from images
• The CNN architecture consists of an encoder-decoder framework along with a pixel-wise regression layer
• The trained model cleanses and restores noisy images to prepare them for further analytic consumption

Learn how to quickly iterate through the data science life cycle from modeling, to evaluation, to deployment using SAS Viya APIs.

• Learn how SAS provides scalable batch and real-time data science environments
• Embed data science into applications with SAS APIs
• Deliver applications from data science development to operation in an agile way

Learn how to use the SAS Job Execution Web App and APIs to build an application.

• Define CORS and CSRF
• Scripting configuration of CORS and CSRF
• Bonus: Configure cross-site cookies

Learn how the R SWAT packate allows R users to use SAS Analytics without a full dive into the SAS programming language,

• Learn how the SWAT package and how it enables open source integration with Viya
• Learn how to submit CAS actions using R to run in-memory analytics
• Explore general integration aspects of tasks and downloading results to the client using R functionality

Incorporate splitters into your SAS Event Stream Processing (ESP) projects.

• Learn how to split ESP streams
• Split to add logic to individual streams
• Split to increase performance

Explore various ways of working with dates and times in SAS Event Stream Processing (ESP).

• Ways to publish data containing dates and times to ESP
• How ESP handles dates and times internally
• Best practices and considerations when working with dates and times

Learn about integrating MS Power Apps and SAS decisions published to Azure with SAS Container Runtime.

• Deploy the SCR image to an Azure Web Application
• Learn how to use the SCR REST API
• Create and publish the application

Learn about the fundamentals of the SAS Viya platform and CAS, then dive into CASL, the scripting language designed to support the entire analytics life cycle

• Explain CASL and its components
• Use CAS actions to submit requests to the CAS server and work with the results
• Develop analytic pipelines using CASL

Learn how to monitor degradation of wind turbines in real-time using SAS IoT analytics.

• Design streaming model for real-time failure detection
• Use subspace tracking algorithm to detect anomalies
• Best practices for subspace tracking algorithm

Learn how SAS provides a collaborative environment for open source developers that fosters productivity and streamlines workflows.

• The available SAS Python packages, their key features and when to use them
• How to work with the packages
• How to get started on your SAS Python journey

Part 3 of series on MS Power App - integrate a Power Automate Flow in a Power App and demonstrate how SAS Viya REST endpoints can be consumed in applications

• Create the Power App
• Connect the app to data sources
• Add the Power Automate flow

Learn how SAS Viya integrates with open source.

• Access SAS using your existing skills, like SAS, open source or other programming skills
• Use Python or R in the analytical flow of pipelines or using the SWAT package
• Use the Python Editor within SAS Studio

Learn how to convert and score SAS Tiny YoloV2 computer vision models leveraging the Intel OpenVINO framework and ONNX format using SAS IoT Analytics.

• Convert and score SAS Tiny YoloV2 computer vision models
• Leverage the Intel OpenVINO framework and ONNX format
• Functional difference between ONNX format and native SAS ASTORE

Learn how to create images of all the graphs in a Visual Analytics report and archive them into a zip file

• Create the image files and package them up
• Add all generated svg files to the archive
• Copy the zip archive to the SAS Viya files service

Learn how to process, analyze and visualize data using Python in SAS Viya.

• How to access data in Viya using Python and the SWAT package
• How to process and analyze data using the Pandas API in the SWAT package
• How to visualize data in Viya using Python

Learn how to make use of SAS decisions published as container images in Azure.

• Benefits of SAS Container Runtime
• Create a container instance in Azure, from a SCR container image
• Ccore the decision using a simple command to call the SCR REST API with curl, python, SAS, etc.

Custom SAS Viya agent in LangChain demonstrates the potential of using LLMs and specific tools to create intelligent, interactive agents

• Create such a smart agent
• Handle detailed operations on SAS tables and respond to user questions based on those operations
• LangChain matches the user's intent with the custom tool

Learn how SAS Viya integrates with open source technologies by improving interoperability and utility.

• The open source languages that are supported and why
• How SAS Viya integrates with open source
• The benefits of using SAS Viya with open source technology

Learn about the new program within the pyviyatools repository: getactivityrecords.py

• A Python script designed to retrieve and analyze activity records from the SAS Viya environment
• The auditing framework gains a higher-level perspective to make auditing more intuitive and understandable
• The program supports multiple output formats, including CSV (default), JSON, and Pandas DataFrames

Part 2 of series on MS Power App - learn how to consume that data through a connector in a Power Automate Flow

• Create the Power Automate Flow
• Add custom connector
• Run the flow and parse the response

Make a connection from SAS 9.4 to SAS Viya using an access token.

• Defining a custom application in SAS Viya
• Generate and access token
• Access SAS Viya services from SAS 9.4

How to create and execute a pricing plan for given products using SAS Retail.

• Create the pricing plan
• Execute the pricing plan
• Extract data from the pricing plan

Learn the fundamentals of the SAS Viya platform and CAS, then dive into CASL, the scripting language designed to support the entire analytics life cycle.

• Explain CASL and its components
• Use CAS actions to submit requests to the CAS server and work with the results
• Develop analytic pipelines using CASL

How to retrieve the KPI information and shortcuts from an API using NodeJS with Express and MongoDB.

• Build the project infrastructure
• Build the code
• Adapt the portal frontend

Learn about the APIs that call machine learning models in SAS® Viya®.

• Make machine learning models available to APIs and how to call those APIs
• Learn how to call SAS programs using a REST API and make them available to external processes
• Review APIs for retraining machine learning models and system automation in SAS Viya

Explore what can be done with the custom client application of SAS Logon Manager

• Authentication and authorization with a custom client
• Custom applications and the credentials microservice
• Example custom client - using job execution service, accessing CAS, and running SAS code

Learn about the SAS built-in tools used to convert JSON to SAS data for analytics

• Learn how to use the JSON libname engine to read JSON into SAS data sets
• Learn how to use JSON maps to control how SAS reads and interprets the raw JSON data
• Learn how to use PROC JSON to create JSON output in SAS

Learn about executing a SAS decision published from SAS Intelligent Decisioning to the Micro Analytic Service with shell commands.

• Code samples for scoring a SAS Decision Published to MAS
• Identify the model to score using the microanalyticScore API
• Authenticate to SAS Viya details

Learn how to interact with SAS Viya REST APIs to create and access SAS resources using any client technology.

• SAS Viya API overview
• Calling CAS Actions via REST APIs
• Use case demo to load table, generate stats, and generate and retrieve a report image

Learn how to add a chatbot to a custom portal.

• What is SAS Conversation Designer?
• How to add a chatbot to the portal page
• Identify botURI location

Learn how to call CAS actions via REST using the CAS REST APIs.

• Explore/navigate CAS action sets and actions documentation
• Use CAS action APIs with SAS Viya APIs
• String multiple CAS actions together, creating end-to-end use cases

Learn how to build models in SAS Viya 4 from a Python client.

• Import SWAT
• Authenticate
• Make the API call and process the results

Learn about Python Zip Model Management (pzmm), a sasctl module created and maintained on GitHub by SAS Model Manager R&D.

• Writes JSON files to read in the model information
• Writes the *score.py model file used for model scoring and serializes a trained model into a binary pickle file
• Serializes a trained model into a binary pickle file

Learn how to display a PDF in a SAS Visual Analytics report.

• Upload PDF file
• Find the PDF by URI
• Embed the file in the report

Learn how to upload files and the folder structure into the SAS Content Server.

• Use the sasctl package load 10K+ files and folders structure in just a few lines of code
• Understand how to interact with SAS Viya REST APIs
• Reduces the time needed to develop a solution as many of the SAS Viya REST APIs endpoints are implemented

How to authenticate against the SAS Logon Manager using the "Authorization code flow" mechanism.

• Choosing "Authorization code flow" - a more secure approach
• Preparing your web app that accesses SAS REST APIs
• Basic steps to create your ReactJS application

Follow the complete model lifecycle using SAS Python SWAT

• Connect to CAS
• Load, explore, and impute data
• Execute the complete model lifecycle: split data, train, score, assess, champion

Unravel the symbiotic relationship between SAS Viya and Python's versatility through the Scripting Wrapper for Analytics Transfer (SWAT).

• Navigate the fundamentals
• Seamlessly integrate these robust technologies
• Unleash a new dimension of analytical possibilities

Learn how to use SAS APIs to build web applications and integrate with open source technologies.

• Introduction to SAS APIs
• Perform actions using SAS REST APIs
• Invoke APIs from various languages

Build HTML prompts for a job and display the result of the job execution on the same page

• Use XML, JSON, or HTML to generate prompts
• How to build cascading promts
• Code is included to build the app

How to update global variables programmatically using the Intelligent Decisioning API.

• Find the global variable URI
• GET the global variable ETag
• Update (PUT) the global variable

Leasrn how you can score data using a model published to SAS Micro Analytics Server

• Use models deployed to MAS to enrich the application with scored data
• Integrate SWAT and SASCTL packages provided by SAS into your Python application
• Create a session and execute the scoring based on the inputs stored in variables

SAS Information Catalog allows you to discover, search, and manage your SAS Viya assets

• Discover, search, and manage your SAS Viya assets, such as data, tables, files, SAS Visual Analytics reports, SAS models, SAS decisions, SAS Studio flows, or code files
• Search the catalog for your assets using keywords or calculated metrics and their values
• View the information privacy status of your assets, which is calculated by the catalog

Explore data management in SAS Viya using a custom LangChain agent and LLMs

• Leverage the LangChain Python library, Azure OpenAI, and SASPY to interact with SAS libraries
• LLM setup and tool definitions
• Chat prompt and agent creation

Discuss with your data as if it were a colleague.

• Turning Queries into Conversations
• Data Speaks Your Language
• Your Data Interaction Playground

Generate SAS code, from a SAS Studio Flow, using a SAS Viya API

• Use the SAS Viya codeGen REST API generate SAS code from a SAS Studio Flow
• Execute the code with a Python program using shell and passing in arguments
• Cleanse the output and obtain the SAS program from the JSON file

Learn about the Job Execution Web Application development environment.

• Analyze and display information on the web and let web users retrieve information
• Combine SAS and web application skills