Embedded Python refers to the integration of the Python programming language into the InterSystems IRIS kernel, allowing developers to operate with data and develop business logic for server-side applications using Python.
In the previous IoP article, I showed how IoP can expose Python messages to DTL by generating JSON schemas. That is useful when the message is primarily a Python object and we want the IRIS tooling to understand its structure.
This time, the direction is a little different.
Starting with IoP 3.7.1, a PersistentMessage can now be a native IRIS message body class. The Python class is still the source code you write, but the generated IRIS class extends Ens.MessageBody
Vector search is a retrieval method that converts text, images, audio, and other data into numeric vectors using an AI model, and then searches for items that are semantically close. It enables “semantic similarity search” from free text, which is difficult with keyword search alone.
However, in real use, I encountered cases where results that are “close in meaning” but logically the opposite appeared near the top of the search results.
This is a serious issue in situations where affirmation vs. negation matters. If the system returns the wrong answer, the impact can be significant, so we cannot ignore this problem.
This article does not propose a new algorithm. I wrote it to share a practical way I found useful when semantic search fails due to negation.
With Embedded Python and the Native API, it is becoming increasingly natural to write part of IRIS application logic in Python. But one question quickly comes up: how can you manipulate IRIS persistent objects from Python without losing the connection to the native object model, class dictionary, indexes, storage, and SQL projections?
iris-persistence explores that question. The project provides a Python object persistence layer for InterSystems IRIS, inspired by %Persistent
InterSystems IRIS globals are one of the platform's core strengths: they store hierarchical data in a direct, ordered, and efficient structure. But when working from Python, manipulating globals can sometimes feel closer to a low-level API than to the natural habits of the language.
The iris-global-reference project provides a Python layer on top of IRIS globals. Its goal is simple: make access to globals more readable, more idiomatic, and easier to integrate into modern Python code, without hiding the underlying hierarchical model.
IRIS Audio Query is a full-stack application that transforms audio into a searchable knowledge base.
community/ ├── app/ # FastAPI backend application ├── baml_client/ # Generated BAML client code ├── baml_src/ # BAML configuration files ├── interop/ # IRIS interoperability components ├── iris/ # IRIS class definitions ├── models/ # Data models and schemas ├── twelvelabs_client/ # TwelveLabs API client ├── ui/ # React frontend application ├── main.py # FastAPI application entry point └── settings.py # IRIS interoperability entry point
When developing Python applications with InterSystems IRIS, you can quickly end up with several execution contexts:
python3 process that loads the Embedded Python libraries from a local IRIS installation;These three cases are useful, but they do not behave exactly the same way for imports, system configuration, object APIs, and SQL access.
Data privacy regulations such as GDPR, LGPD, and HIPAA demand that organizations know exactly where Personally Identifiable Information (PII) lives inside their databases. Yet in practice, most teams rely on manual inventories, tribal knowledge, or external scanning tools that require data to leave the database engine — a process that itself creates privacy and security risks.
This article presents an MVP that takes a different approach: it runs PII detection inside InterSystems IRIS using Embedded Python, analyzing data where it lives and never exporting it to an external process.
Solar irradiance forecasting is critical for grid stability in photovoltaic (PV) power plants. This article replicates and extends the methodology of Lara-Benítez et al. (2023) "Short-term solar irradiance forecasting in streaming with deep learning" replacing the original offline simulation with a fully operational streaming pipeline built on InterSystems IRIS. We leverage IRIS Interoperability Productions as the streaming backbone, Embedded Python to run MLP, LSTM, and CNN deep learning models, and IntegratedML as an AutoML baseline.
The Interoperability user interface now includes modernized user experiences for the DTL Editor and Production Configuration applications that are available for opt-in in all interoperability products. You can switch between the modernized and standard views. All other Interoperability screens remain in the Standard user interface. Please note that changes are limited to these two applications and we identify below the functionality that is currently available.
To try out the new screens prior to upgrading, you can download the 2025.
Hey Community,
Yeah, I know we have a lot of tips & tricks articles - we even have a special tag for it, right? But I can not share my own collection. In this collection, you can find snippets for beginners, as well as some everyday ObjectScript constructions. In fact, it's also a way to learn something new about my favorite programming language. So, if you guys have anything to add, you are welcome!
Today I have published a new Open Exchange package for generation of Synthetic Data directly into IRIS.
It can be a frustrating process to find decent datasets when you are looking to make a demo app. Maybe the dataset doesn't matter that much, but you still want it to appear somewhat genuine and with several linked tables that are usable directly within IRIS with the neat implicit joins with ->. Maybe you just want linked tables that are easily installable with IPM to benchmark queries, this dataset generation would be perfect.
I need a %SYS.Python object that will be accessible from different processes. The goal is to avoid reinitializing the Python object whenever it is called. Ways that I checked and decided that it is NOT what I want:
Next, my ideas (none of them look like a silver bullet):
A microservice is an architectural style that structures an application as a collection of small, autonomous services. Each component is developed around a specific business capability, can be deployed independently, and is typically managed by a miniature, specialized, self-governing team. (Source: https://microservices.io/)
I'm a huge sci-fi fan, but while I'm fully onboard the Star Wars train (apologies to my fellow Trekkies!), but I've always appreciated the classic episodes of Star Trek from my childhood. The diverse crew of the USS Enterprise, each masterminding their unique roles, is a perfect metaphor for understanding AI agents and their power in projects like Facilis. So, let's embark on an intergalactic mission, leveraging AI as our ship's crew and boldly go where no man has gone before
As part of a recent documentation technical project to optimize the search, I needed to use Embedded Python in my ObjectScript code. The main blocker was passing a Python list from a Python class method to a ObjectScript method. Sending the list by reference to the python method, populating it with the Insert() method, and returning the reference to the ObjectScript method resulted in an list with type %SYS.Python, a process that was straightforward but not efficient.
I explored an alternative method: converting a Python list to an ObjectScript list using JSON as the intermediary format.
Since I started using Claude Code, my motivation to create things has skyrocketed.
Previously, even if I wanted to build something, actually doing the coding felt like a hassle, so unless there was a very strong need, I rarely went as far as programming. But now, if I just jot down the specifications, Claude Code handles the rest automatically, resulting in a dramatic improvement in productivity.
I come from a generation native to ObjectScript, so I used to feel some hesitation when it came to switching to Python.
Working with files often starts off simple. open the file, read, and process. That approach works perfectly well, until the file happens to be an Excel file.
A Common Assumption
At first, an Excel file (.xlsx) looks like just another data file, rows, columns and values. nothing unusual. So it's natural to assume it can be read the same way as a .txt ot .csv file. But that's where things start to break.
Why Excel files behave differently
The key difference is how the data is stored:
-> .txt / .csv - plain text, line-by-line.
-> .
Imagine you’re walking down the street on a nice summer’s day, and someone walks up to you and says “Hey, you work at InterSystems, right? I’ve been hearing more and more about InterSystems IRIS lately. I know IRIS has its own programing language called ObjectBook? or InstaScript? OK, I admit it, I know it’s called ObjectScript! I know IRIS also supports Python. I’m a Python developer, so that sounds great to me. But I’m also interested in ObjectScript. For example, Python and other languages support collections. Does ObjectScript support collections?”
You’d answer “Of course!”
And then your new friend might get excited and start firing off more questions:
How would you answer? Well, you don’t have to worry about answering. All you’d have to do is send your new friend the URL of this long page.
USER>do$System02/03/25-18:27:39:497 (13156) 1 [Generic.Event] CPF settings (PythonRuntimeLibraryVersion) do not specify python correctly - Python can not be loaded 02/03/25-18:27:39:498 (13156) 1 [Generic.Event] CPF settings (PythonRuntimeLibrary) do not specify python correctly - Python can not be loaded
my iris.CPF just shows nothing. what is the correctly formatted content ?
^CONFIG("config","PythonPath")=""
^CONFIG("config","PythonRuntimeLibrary")=""
^CONFIG("config","PythonRuntimeLibraryVersion")=""1 Introduction
In environments that use InterSystems IRIS, globals are the physical foundation of data storage. Although system queries and administrative tools exist for metric inspection, global growth analysis is usually reactive: the problem is generally only noticed when there is disk pressure or performance impact.
Picture a dark room. The only light comes from a wall of displays and a blinking prompt that politely informs you:
“LINK TO M-U5K-3T: HIGH LATENCY – DIRECT CONTROL DISABLED.”
Perfect.
You are supposed to be a Rover Commander in the Musketeer Corps. Somewhere absurdly far away, you have an autonomous unit parked on a hostile exoplanet. It wants you dead, but it’s also covered in minerals that could fund a small civilization.
The ore on M-U5K-3T is everywhere. Unfortunately, everything else on the surface is actively trying to kill you.
So, we don't pilot. We script.
In the modern healthcare landscape, finding clinically similar patients often feels like looking for a needle in a haystack. Traditional keyword searches often fail because medical language is highly nuanced; a search for "Heart Failure" might miss a record containing "Congestive Cardiac Failure."
I am excited to share iris-medmatch, an AI-powered patient matching engine built on InterSystems IRIS for Health. By leveraging Vector Search, this tool understands clinical intent rather than just matching literal strings.
Hello everyone,
I’m looking to implement Continuous Training (CT) as part of an MLOps strategy for some data science projects in IRIS. I want to automate the full cycle:
- Monitoring model performance & accuracy degradation.
- Retraining models automatically.
- Validating and updating production models.
I’ve looked into IntegratedML, but it seems more focused on the SQL interface for training (AutoML). Even with the new Custom Models (beta), which allows for more flexibility with Python, it doesn't seem to provide the "Continuous" orchestration out of the box.
I’d like to know:
One objective of vectorization is to render unstructured text more machine-usable. Vector embeddings accomplish this by encoding the semantics of text as high-dimensional numeric vectors, which can be employed by advanced search algorithms (normally an approximate nearest neighbor algorithm like Hierarchical Navigable Small World). This not only improves our ability to interact with unstructured text programmatically but makes it searchable by context and by meaning beyond what is captured literally by keyword.
In this article I will walk through a simple vector search implementation that Kwabena Ayim-Aboagye and I fleshed out using embedded python in InterSystems IRIS for Health. I'll also dive a bit into how to use embedded python and dynamic SQL generally, and how to take advantage of vector search features offered natively through IRIS.
In this article, I aim to demonstrate a couple of methods for easily adding validation to REST APIs on InterSystems IRIS Data Platform. I believe a specification-first approach is an excellent idea for API development. IRIS already has features for generating an implementation stub from a specification and publishing that specification for external developers (use it with iris-web-swagger-ui for the best results). The remaining important thing not yet implemented in the platform is the request validator. Let's fix it!
PEP 578 added Python Audit hooks. A rich variety of events (module load, os interactions and so on) triggers audit events which you can subscribe to.
Here's how to do that. First create an embedded python hook:
Class/// do ##class(User.Python).Audit()ClassMethodIn this example we:
All of that will be written to the default STDOUT.
1-command only required for an entire IRIS instance for Data Science projects, and leveraging this to compare query methods' speed (Dynamic SQL, Pandas Query, and Globals).
Before joining InterSystems, I worked in a team of web developers as a data scientist. Most of my day-to-day work involved training and embedding ML models in Python-based backend applications through microservices, mainly built with the Django framework and using Postgres SQL for sourcing the data.
Here are the technology bonuses for the InterSystems Full Stack Contest 2026, which will give you extra points in the voting:
See the details below.
Overview
Embedded Python is a game-changer for InterSystems IRIS, offering access to the vast Python ecosystem directly within the database. However, bridging the gap between ObjectScript and Python can sometimes feel like translating between two different worlds.
To make this transition seamless using embeddedpy-bridge.
This package is a developer-centric utility kit designed to provide high-level ObjectScript wrappers, familiar syntax, and robust error handling for Embedded Python.
Hi developers!
Happy holidays!
In ObjectScript there is neat option to log errors - call Log() method of an exception intance, e.g.:
ClassMethod MyMethod() {
Try {
w 1/0
}
Catch e {
do e.Log() // logging error in the app log
write "the error happened: "_e.DisplayString()
}
}Is there anything like that for Embedded Python? e.g:
ClassMethod MyMethod() [Language = python] {
try:
print(1/0)
except ZeroDivisionError as e:
// how can I log e into IRIS App Error Log here?
print("Caught exception: " + str(e))
}Any ideas?