Hi, community!

There's a Russian proverb: "to kill two rabbits with one shot". In English, if I'm not mistaken, it's "to kill two birds with one stone". We won't kill anyone, but we'll try to implement two ideas at once: DPI-I-543 about Hugging Face and DPI-I-1012 about Kaggle. Both ask for a way to get a public dataset into IRIS without manual work. And test them on a real project rather than a toy example. Well then.

Built for the InterSystems Programming Contest: Build Your Own Management Portal

By Murilo Przybyloviecz and Andre Larsen Barbosa

MyOwn Portal is a compact, English-language administration interface for InterSystems IRIS and IRIS for Health, built for the InterSystems Programming Contest: Build Your Own Management Portal. The browser application is React and TypeScript; every piece of administrative logic — authentication, authorization, auditing, and the reads and writes against IRIS system data — is implemented in ObjectScript behind a REST layer. Vite and Node.

Hi Community,

Administering InterSystems IRIS means opening a lot of pages. The Management Portal is complete and it is dependable, but it grew as a tree over two decades, and three ordinary tasks cost more than they should.

Finding a screen depends on knowing where it lives. There is no search across administrable objects, so the path to a page is memorised rather than typed.

Connecting two facts is manual. A resource does not show who consumes it. A log line does not lead to the process that wrote it. The chain lives in the administrator's head.

In the previous article, we used pyprod to create production components while relying on the UI for production configuration. That same production can now be defined entirely in Python:

from intersystems_pyprod import Production, ServiceItem, ProcessItem, OperationItem

iris_package_name = "HelloWorld"

class MyProduction(Production):
    services = [
        ServiceItem(
            "MyServiceName",
            "HelloWorld.MyService",
            host_settings={"target": "MyProcessName"},
        )
    ]
    processes = [
        ProcessItem(
            "MyProcessName",
            "HelloWorld.MyProcess",
            host_settings={"target": "MyOperationName"},
        )
    ]
    operations = [
        OperationItem("MyOperationName", "HelloWorld.MyOperation")
    ]

## Why another management portal?

The built-in IRIS Management Portal is powerful and complete, but its key operational signals — cache efficiency, global activity, web applications, users and roles, scheduled jobs, security events — are scattered across many menu levels. When you are on call and need to answer *"is this instance healthy right now?"* in ten seconds, that matters.

**LuminIRIS** is my contest answer: a single-pane, dark-themed **glassmorphism** console where the five management scenarios an operator actually uses every day live behind one login:

1.

An Evidence-First Operations Environment for InterSystems IRIS

I wanted a management interface that made it easier to understand what InterSystems IRIS was telling me. Finding the information was part of the problem. Keeping track of what I had learned, what I was about to change, and whether the change actually happened was another part, and it became the more interesting one.

The Management Portal has a great deal of functionality.

Hi Community!

Before all: demo is live, you can try it right now - https://docket.antonyartsev.com, login docket / 12345.

This is my first contest and i want to tell how it was.  Topic was Build Your Own Management Portal exactly the work which I like most: take complex data and make from it interface which updates in real time. For me place or prize is not so important, more important is feedback. So if you think this is wrong or no real admin needs this please write me.

On the suitcases

Contest started exactly when I was moving to other country.

Hi Community,

We’ve launched a new free, interactive tutorial that provides a practical introduction to building interoperability productions with InterSystems Python Productions (intersystems_pyprod Python library).

🐍 InterSystems PyProd Tutorial 🧑‍💻

Hi Community!

In this article, I will introduce my application iris-command-center.

The idea is simple: bring the information and operational tasks that normally require moving between different areas of the Management Portal into one modern operational console.  

But while building it, the project grew into much more than a dashboard.

It now includes live system exploration, controlled administration, security review, REST API exploration, native audit investigation, issue detection and resolution, execution tracing, IRIS Vector Search, Embedded Python diagnostics and an AI-assisted interface.

TL;DR SentaiTask is a management portal for InterSystems IRIS built around orchestration: you draw maintenance as a flow (steps in parallel waves, joins that wait for all their inputs), it validates the flow, IRIS runs it, on this instance or on other servers, and you watch every step live. On top of that: an Overview of the instance in 11 cards, seven security and health reports (including certificates about to expire), schedules that become native Task Manager tasks, a run log, history and export for every run, and step search by intent with the model running inside IRIS.

Before I change a role in IRIS, I want to know who will be affected and which permissions will actually change. If I start an integrity check, I want to follow it without keeping the original page open. If an error appears in a log, I want to know whether we have seen the same pattern before.

Those were some of the practical questions behind Aperture, my entry for the InterSystems Build Your Own Management Portal contest. IRIS 2026.2 ships with a documented SysAdmin REST API containing 273 operations for databases, namespaces, processes, journals, tasks, licensing, security, and more.

Live demo: https://niutics.pl/interSystems (sign in as demo / demo, or operator / for a limited role) · GitHub: https://github.com/DawidKrynski/iris-admin-deck · Open Exchange: https://openexchange.intersystems.com/package/IRIS-Admin-Deck

Video, 3 minutes: https://youtu.be/gUsxZi-uAD4

IRIS 2026.2 added the SysAdmin REST API, . Its OpenAPI file has 190 paths and 273 operations and covers most of what I normally do in the Management Portal. For the

There are a lot of useful projects on Open Exchange that are easy to miss. Here are 10 worth bookmarking if you develop with InterSystems IRIS.

Environment

• InterSystems IRIS for Health, Community Edition, image intersystemsdc/irishealth-ml-community:2026.1
• Platform: Docker, Ubuntu 24.04 LTS host, aarch64 (Apple Silicon / ARM64)
• Embedded Python: 3.12.3 (confirmed via ##class(%SYS.Python).GetPythonInfo()), CPF_PythonPath correctly set to the packages directory
• sklearn, , all import cleanly through the embedded Python bridge

Problem

Every TRAIN MODEL ... USING {...} call fails with NoEstimatorChosen, regardless of:

• (tried , 0.50, and omitted entirely — all fail)

An election happening now

It is August 2026, and Brazil's general election campaign is underway. On October 4, 158,745,463 eligible voters may choose a president, state governors, senators, federal representatives, and state or Federal District representatives. A possible presidential and gubernatorial runoff is scheduled for October 25. The dates and electorate come from Brazil's Superior Electoral Court.

This timing turns public information into an immediate civic need as millions of people try to understand candidacies, proposals, and public careers.

I currently use pyenv on my local machine to manage my Python installations. I just installed IRIS on my Mac, and am currently trying to configure Embedded Python. I read from the docs that it's recommended to install from Homebrew. Since this was only recommended, I figured I could try to configure IRIS with my installation of 3.11.16, which I built with env PYTHON\_CONFIGURE\_OPTS="--enable-shared" to ensure that Python wasn't built statically (as is the default behavior). Building it this way then gave me a .dylib

After an extensive math lesson, we are going to put our new knowledge into practice and create one of the best context-related databases.

Get your magnifying glasses and hats ready, because Vector Holmes is back.

If you are a regular on the developer community, you may have seen some recent posts about the InterSystems First Employee Programming competition. The challenge is simple — transform some Gaia Epoch Photometry data, calculate the percentage change of flux (between the maximum and minimum values), and output a list of the stars with a percentage change of greater than 100.

Now while this was a fun challenge, but I felt there was something missing: a lack of scope for creativity After all, we are looking at stars!

Most of these stars in the Gaia challenge will never have a name. They sit in the Gaia archive as an 18-digit number and a column of flux readings, and none of that lets you feel what they are. Lumeon is my attempt to change that: to take these unnamed, changeable stars and give them a sky you can wander and ask about in plain words.

Live demo: https://lumeon.vercel.app.

Hi Community,

I built a small network of clinical AI FHIR agents on IRIS for Health, and I want to share the actual pieces that made it work.

In this article, we will cover the following points

• Agentic AI stack
• Agent routing logic
• FHIR read and write access (tools)
• RAG loading with a fallback
• Oncology agent: config to test result
• Two-agent routing example

This project is an InterSystems IRIS Interoperability On Python, or IoP, application for the Gaia DR3 epoch photometry benchmark.

It processes the first 20 Gaia DR3 epoch photometry archives, computes BP/RP flux variation by source_id, and writes the qualifying results to output/results.csv with a header row.

Goal

The benchmark asks for every astronomical object whose BP or RP flux changed by more than 100 percent over the observation period.

For each source_id, the application:

1. Reads only the first 20 Gaia DR3 epoch photometry files, from EpochPhotometry_000000-003111.csv.gz

Hello Community!

We’re excited to invite you to our upcoming Hebrew webinar, presented by @Ariel Glikman, an InterSystems Sales Engineer:

👉Beyond Code Generation: Agentic Development for InterSystems IRIS 👈

📅 Date & time: July 21st, 3:00 PM IDT

Show Community: Processing ESA GAIA files until we hit the decompression floor

InterSystems is running its first employee coding contest, contest #47: scan the Gaia DR3 epoch-photometry archive and flag every star whose BP or RP flux changed by more than 100% across its observation history., ISC-Programming-Challenge-GAIA, currently holds both #1 and #2 on the speed leaderboard, submitted with two versions of the same pipeline.

The task

Take 20 gzip-compressed ECSV files, with ~47 columns, but only three matter: source_id, bp_flux, rp_flux. Each flux column is a quoted string like

A Better Developer Experience With PollingBusinessService

One of the most visible additions in 4.0.0 is PollingBusinessService.

Before this release, creating a scheduled Python business service meant dealing directly with the low-level inbound adapter pattern. In 4.0.0, a scheduled Python entry point can be written directly as a PollingBusinessService and the framework uses the default IRIS inbound adapter behind the scenes.

In my first article, I described the baseline version of the FHIR Patient Snapshot Agent: a Streamlit and Python application that retrieves FHIR resources from InterSystems IRIS for Health and uses an LLM to generate a concise patient summary.

This follow-up article explains how I extended the project with two additional InterSystems-focused features:

• Source context vector search
• Embedded Python artifacts for IRIS-compatible review

The goal was to make the project more useful as a clinical summarisation prototype while keeping the design small enough to understand and reproduce.