r/intersystems • • Apr 29 '25

Generating an ObjectScript Class from JSON Response Using ChatGPT

2 Upvotes

🤖 Learn how to generate an ObjectScript class from #JSON response received from #ChatGPT to save it into an #InterSystemsIRIS database 👇

https://community.intersystems.com/post/generating-objectscript-class-json-response-using-chatgpt

Check out what can be done with ChatGPT’s help!


r/intersystems • • May 13 '25

InterSystems FHIR and Digital Health Interoperability Contest 2025

0 Upvotes

🏥 Are you ready to transform #healthcare with code? Join the InterSystems #FHIR and Digital Health #Interoperability Contest, where innovation meets impact! Build open-source solutions with #InterSystemsIRIS and compete for your share of $12,000 in prizes 💰

🗓️ Dates: May 12 – June 1, 2025

🔗 Details: https://community.intersystems.com/post/intersystems-fhir-and-digital-health-interoperability-contest-2025

Step up, code smart, and shape the future of digital health!


r/intersystems • • May 10 '25

InterSystems Ready 2025

0 Upvotes

The countdown to InterSystems Ready 2025 has begun!

Join us in Orlando, Florida, from June 22-25 for an event you won't want to miss.

Connect with industry leaders, explore new features, and dive into the latest AI trends. Register today: https://hubs.li/Q03d6mQl0

#Ready2025 #InterSystems


r/intersystems • • May 16 '25

Generating an ObjectScript Class from JSON Response Using ChatGPT

0 Upvotes

🤖 Learn how to generate an ObjectScript class from #JSON response received from #ChatGPT to save it into an #InterSystemsIRIS database 👇

https://community.intersystems.com/post/generating-objectscript-class-json-response-using-chatgpt

Check out what can be done with ChatGPT’s help!


r/intersystems • • 3d ago

How do you run Git and CI/CD for HL7 interfaces in InterSystems Health Connect? Trunk-based flow and a real setup from Albany Med

Thumbnail
youtu.be
0 Upvotes

This is a summary of a session on source control and continuous delivery for InterSystems IRIS and Health Connect, given by Eduard Lebedyuk (InterSystems) with Liam Miller, director of IT integration at Albany Med Health System (four regional hospitals, 1,600+ beds). It explains why a trunk-based flow fits interface work better than GitLab flow, shows Albany Med’s variant with one namespace per analyst, and covers deployment details specific to interoperability productions. Most of it applies to self-hosted setups too.

Why use source control and CI/CD?

  • You can answer “what ran in prod a year ago?”, “who wrote this line?”, and “what changed between two dates?” from the repository

  • Fewer manual actions means fewer errors: a full deploy is one button

  • Tighter access: only maintainers press the deploy button and have access to prod

  • A change record that auditors like, useful for HITRUST, HIPAA, and SOC 2

What is the difference between GitLab flow and trunk-based development?

GitLab flow uses environment branches: what is in the dev branch is what runs in dev. You branch from dev, merge the feature into dev, then promote dev into test and test into prod. This works for application development, but HL7 interfaces land in dev and test in any order and stay in test for a long time, so test is never ready to promote as a whole.

In trunk-based development a feature branch starts from prod and the same branch is merged into dev, then test, then prod. Features are promoted individually, and there are no merge conflicts from merging dev into test.

How does Albany Med run it?

Prod is main (protected), plus test and dev in their cloud tenant. Each analyst (eight today, eleven at the start) has an individual namespace in dev.

  1. Create a feature branch from main and load it into your namespace

  2. Make your changes, then merge the namespace branch into dev (the key step: it avoids constant push and pull and most merge conflicts)

  3. Promote to test, run user testing, get sign-off

  4. Before production, merge main into your feature branch to capture hot fixes, enhancements, and other releases that went live meanwhile

  5. Merge the feature branch directly into prod, bypassing test (never merge test into prod)

  6. Merge the same branch back into test, so test stays in sync while keeping what is still in flight

Their lessons: name branches by type (feature, about 90% of work; hotfix; bugfix; experimental) plus initials, product, date, and ticket number (ServiceNow incident or request number). Segment files into folders (classes, lookup tables, DTLs) so you import and compile only what you need. Hold a daily 3 pm review of dev-to-test merges (5 to 10 minutes). Restrict who can merge into protected branches until the team is comfortable.

Result: for their Epic cutover, 88 interfaces were turned on almost simultaneously, and a production deploy is now a button click.

How do you update a running production?

The simplest way is stop, update, start. Without downtime:

ItemBehavior
Lookup tables and HL7 schemasBefore the latest version they were deleted before import, causing brief errors (missing schema, table, or key), so affected items had to be stopped. Version 2026.1 supports updating in-use ones without stopping items
System default settingsApplied only at job start or on an explicit update production call, so loading is safe
DTLs and business rulesActive immediately after compilation
Business processes, operations, servicesNeed an item restart

Also export the current configuration at the start of every deploy, to catch changes made directly on a server.

How do you shorten deployment time?

  • Split item types into folders and split CI jobs by path, so each job runs only when its folder changes

  • Use git diff between the last deployed commit hash and the new one: load added and modified files, translate deleted file names into item names and delete them, then store the new hash

  • Load several sources first, get the list of loaded items, and compile once

How do you handle one codebase for many clients?

Use configuration first (system default settings are not tied to interoperability, so you can use them for your own application settings). For custom code, pick one approach: same class name with different versions per client, or different class names (ABC1, ABC2) selected by a setting. A good pattern is a baseline template repository that customization repositories reference as a submodule.

What about containers and Kubernetes?

Building containers is the preferred approach, but an update requires a failover. If you work with TCP devices that cannot renegotiate without a full restart, update the code in place: a GitLab runner container for Kubernetes connects to the IRIS container and updates the code.

Q&A highlights

  • Tasks are tracked in ServiceNow, not integrated; the ticket number goes in the branch name

  • Deleting a file from the branch does not delete it from the server. Albany Med runs a SQL report that emails unused classes, lookup tables, and DTLs daily, and analysts delete them manually via VS Code

  • Other namespaces and repos: dev, test, and prod branches deploy to the same-named namespace; any other branch deploys to dev and switches to the namespace with the branch’s name, exiting if none exists, so new developers need no CI/CD changes

  • In InterSystems public cloud, SSL configs, web apps, and SQL gateways are defined in a separate control plane and arrive in the data plane already configured

Links: recording [link]; CI/CD series: https://community.intersystems.com/post/continuous-delivery-your-intersystems-solution-using-gitlab-index

How do you promote interface changes today: whole environments or feature by feature, and how do you clean up items deleted from the repo that still linger on the server?


r/intersystems • • Apr 20 '26

InterSystems Ready 2026

0 Upvotes

Your stack is only as powerful as your understanding of it.

READY 2026 is where developers and architects gain the depth needed to build high-performance, future-ready applications with u/InterSystems technology.

The agenda is built for technical teams:

🔍 Breakout sessions on architecture, scaling, and modernization

🤖 AI implementation frameworks

🧪 Deep-dive workshops + 1:1 expert troubleshooting

🔁 Repeated technical tracks so you can catch everything

🧭 Product roadmap sessions: what’s coming and how to prepare

If your organization depends on your code, your architecture, and your decisions—this week matters.

Your expertise becomes your competitive advantage.

🔗 Register today: www.intersystems.com/r26


r/intersystems • • 4d ago

How do you put an InterSystems IRIS app under real version control and auto-deploy it from GitHub to AWS? Server-side Git hooks, promotion by path, and rollback without snapshots

0 Upvotes

Most Git workflows assume files are the source of truth. In IRIS the database is. This article, written for developers and DevOps engineers who maintain IRIS or HealthShare applications, covers how to get verifiable Git history and repeatable deployments instead of manual code exports and copy-paste promotions.

The framework has two halves: a server-side source control class that commits every save to Git, and a GitHub Actions pipeline that pushes approved commits to a target namespace via the Atelier REST API. According to the author, the hard parts aren’t the automation itself but running Git as the IRIS service account and rolling back when a compilation fails.

Why can’t you use a normal Git workflow with IRIS?

Classes, routines, DTLs, BPLs, and lookup tables live in the namespace. Developers edit them through VS Code over isfs://, the Management Portal, or Studio, all on the same shared server. A local-clone-and-push model doesn’t describe what actually happens.

So the version control goes inside IRIS. You subclass %Studio.SourceControl.Base, and IRIS calls your methods when a document is saved, deleted, or opened. The hook exports the document to a file on disk and commits it. Every edit path fires the same hook.

What do you have to decide for the server-side hook?

DecisionThe trade-off
Check-out lockingPrevents collisions and gives a unit of work, but adds friction and stale locks. No locking works for small teams but gets riskier as they grow
Commit granularityOn check-in only (clean history, unprotected work in progress), on save with squash at check-in, both, or every save (noisy, but an accidental overwrite stays recoverable)
Push timingOn save keeps the remote current but a network issue can hang a save. On a schedule keeps saves fast, but work exists only on that server until the push
Hook failureReturn the error (nothing saved without a commit, but a Git misconfiguration can stop the team) or return success and log it (editing never breaks, but failures can go unnoticed)
Export formatUDL for .cls, .mac, .int, .inc (readable diffs). XML only for types with no UDL form
LayoutMirror the package hierarchy (MyApp.Billing.Report.Summary.CLS becomes src/MyApp/Billing/Report/Summary.cls) or flatten
ScopeInclude list (failures are quiet) or exclude list (failures are loud, which is easier to notice)
ReconciliationTrust the hooks, or add a scheduled git add -A sweep to catch what they missed

How does promotion work?

The branches mirror the environments: dev (the shared server auto-commits here on every save), test (curated promotions by pull request), and main (production). Promotion doesn’t have to mean merging all of dev into test. If packages are project-named, each one is a directory, and a directory is a shippable unit:

rm -rf src/MyApp/Billing/
git checkout dev -- src/MyApp/Billing/
git add -A src/MyApp/Billing/

The order matters. git checkout dev -- <path> can only write files that exist on dev, so a class deleted during development leaves a stale copy on test. Removing the directory first makes the checkout reproduce dev exactly, and -A records the removals as deletions.

Two habits keep this working:

  • Don’t edit test or production directly. Fixes go to development first so all environments stay identical

  • Avoid squash merges between environment branches. A squashed commit on main has a new hash that Git can’t match to anything on test, so the branches look divergent and every later diff includes changes that already shipped. Squashing on a feature branch is fine

Done this way, a pull request from test to main shows exactly what production runs now versus what is about to ship, so the release note assembles itself.

How should the pipeline reach the server?

If your IRIS server runs in a cloud, the Git provider doesn’t need to reach it. The article compares three options:

  • CI connects over SSH or a remote-execution protocol with a stored key. Fewest moving parts, but the credential doesn’t expire and a listening port has to be defended

  • CI drives the cloud’s management agent with short-lived federated credentials. No inbound port and no stored key, but one more service to configure. With GitHub Actions and AWS: Actions request an OIDC token, AWS exchanges it for temporary credentials on a deploy role, and the workflow asks Systems Manager to run a registered command on the instance

  • The server pulls. An agent on the instance polls the branch and deploys. Nothing external authenticates to the server, but you lose the direct line between a merge and a visible pass or fail

Credentials: keep the deploy credential out of the repository, the workflow definition, and the deploy script. Beyond that, it’s a set of dials: where it lives (CI secret versus a cloud-side secret store), how finely it’s partitioned (per environment limits a leak to one environment), and how often it rotates. One constraint can’t be avoided: the deploy user needs write and compile rights in the target namespace. Since application data usually lives in the same namespace as the code, scoping the database resource buys less than it appears to.

How do you deploy and roll back?

Deployment approachTrade-off
Per-file Atelier PUT, then compileSimple and debuggable, but a bulk load of tens of thousands of documents will exceed any sane command timeout
Batch Atelier endpointsFar fewer round trips, but verify the request body format for your IRIS version
Import from a local checkout inside IRISBest for the initial load, no HTTP. $system.OBJ.LoadDir(), ImportDir(), and Load() are deprecated in favour of $system.OBJ.Import()
Parallel uploadNot recommended: concurrent writers contend on the class dictionary, locks, and storage assignment

Rollback: reapply Git HEAD. The script only advances HEAD on success, so at failure time HEAD is the last known good state. Re-upload the HEAD versions of modified and deleted files, and delete the files this deploy added. A filesystem backup directory is redundant, and an auto git revert and push was rejected because the deploy box shouldn’t push to a shared branch. EBS snapshot restore is the wrong tool for routine rollback: code and data share the namespace, so restoring discards every transaction since the snapshot. Snapshots belong to disaster recovery.

Deletions: import-style operations only add and update, so a class deleted in development survives on test and production unless the deploy reconciles explicitly. Send additions, copies, and modifications to upload-and-compile, and deletions to a delete call. Use --no-renames, or a rename becomes an update that orphans the old document.

What goes wrong in practice?

  • Git’s dubious ownership check on Windows. If the repo owner differs from the service account, Git refuses to operate. Without exit-code checks at each step, this shows up as a successful deploy that deployed nothing

  • Reading git fetch progress as a failure. Git reports progress on the error stream even on success. The exit code is what matters

  • Assuming Git runs as you. The hook runs as the account the database service runs under, so the SSH key must be in that account’s profile. Specify it explicitly from the repo config rather than relying on HOME, and invoke Git by absolute path, since a service inherits the PATH from when it started. Running the same command interactively as yourself fails on the key and tells you nothing about the hook

  • Line endings. If the repo stores LF and developers use mixed platforms, set the conversion setting deliberately on the server. Getting it backwards produces a whole-file diff on every save

Quick answers

  • What should the pipeline deploy first? Classes only. BPLs and DTLs are classes, so they’re covered. Routines and includes can be excluded deliberately, and lookup tables upload like classes but stay out of the compile list

  • Is it HIPAA-appropriate? The pipeline moves code, not patient data. Guard the leak points: CI logs (a provider’s build logs are generally not covered by a business associate agreement), the repository, and credentials. Confirm every AWS service in the path is HIPAA-eligible and a BAA is in place

The takeaway

Version control for IRIS has to start inside the database, because that’s where the code lives and where every edit path converges. After that, most things are choices rather than requirements, and they should follow from what the namespace holds and who can merge, not from a template. The one constant: every step has to report failure honestly. The dangerous deploy isn’t the one that breaks loudly, it’s the one that reports success and changes nothing.

Full article: https://community.intersystems.com/post/cicd-intersystems-iris-server-side-git-automated-deployment-aws

If several developers share one IRIS server in your team, do you enforce check-out locking, or rely on commit history to untangle collisions? And what made you choose that?


r/intersystems • • Feb 04 '26

Taking the Fear out of FHIR - Fast Tracking Organizational FHIR Readiness

0 Upvotes

At #Ready2025, we moved beyond the hype to examine what it really takes to make #FHIR work in practice, focusing on real organizational needs, proven use cases, and lessons learned.

Watch this #video to discover:
✅ Key success factors for accelerating organizational FHIR readiness.
✅ How use-case-based training helps teams effectively apply FHIR capabilities in #InterSystemsIRIS for Health and #HealthShare Unified Care Record.

https://community.intersystems.com/post/video-taking-fear-out-fhir-fast-tracking-organizational-fhir-readiness

Learn how to turn FHIR potential into measurable, real-world impact.


r/intersystems • • Apr 26 '18

EDIFACT Scheme or SEF

Thumbnail
community.intersystems.com
0 Upvotes

r/intersystems • • Apr 26 '18

How to see the ACK in Visual TRACE page as like HL7 ACK message for custom TCP Operation?

Thumbnail
community.intersystems.com
0 Upvotes

r/intersystems • • Apr 26 '18

DNI functions

Thumbnail
community.intersystems.com
0 Upvotes

r/intersystems • • Feb 15 '19

InterSystems IRIS for Health™ Data Platform Now Available on All Major Cloud Providers

Thumbnail
community.intersystems.com
1 Upvotes

r/intersystems • • 19d ago

InterSystems Programming Contest: AI Agents in Interoperability Workflows

0 Upvotes

⏳ The deadline is approaching for the InterSystems Programming Contest: AI Agents in Interoperability Workflows.

There’s still time to join the competition and get your project ready before the submissions close. Build an #InterSystemsIRIS Interoperability solution where an AI Hub agent handles a decision-making task, and show how agentic logic fits into your workflow.

💰 $12,000 prize pool

📅 Submit by November 8, 2026

👉 Learn more about the challenge and join in:

https://community.intersystems.com/post/intersystems-programming-contest-ai-agents-interoperability-workflows


r/intersystems • • 18d ago

How do you add semantic vector search to InterSystems IRIS for Health using Embedded Python, Ollama, and an HNSW index?

0 Upvotes

Vector embeddings encode the semantics of text as high-dimensional numeric vectors. An approximate nearest neighbor algorithm like Hierarchical Navigable Small World (HNSW) can then search that text by context and meaning, beyond what keywords capture literally. This article walks through a simple implementation in InterSystems IRIS for Health using Embedded Python. It also covers Embedded Python and Dynamic SQL in general, and how to use IRIS’s native vector search features.

Environment

ComponentVersion / detail
OSWindows Server 2025
DatabaseInterSystems IRIS for Health 2025.1
IDEVS Code with InterSystems Server Manager
Python3.13.7
Python librariespandas, ollama, iris
EmbeddingsOllama 0.12.3 with the all-minilm model, run locally (no API key needed)
SQLDynamic SQL
Sample dataA database of classic poems (unstructured text)

Step 1: Define an auxiliary table

The embeddings table User.SamplePoetryVectors has a foreign key on User.SamplePoetry and an EMBEDDING property of type %Library.Vector. Ollama’s all-minilm generates 384-dimension embeddings, so the vector length is constrained to 384.

To use IRIS’s native HNSW index and vector search methods, you need a column of type %Library.Vector (or %Library.Embedding) of fixed length, with type decimal or double, to index on.

Step 2: Vectorize the table with Embedded Python

A RegisteredObject class holds the vectorization methods. The VectorizeTable() class method calls a driver function that does four things:

  1. Loads the table from IRIS into a pandas DataFrame

  2. Generates an embedding column and converts it to a string compatible with the IRIS vector type

  3. Writes the DataFrame into the auxiliary table

  4. Creates an HNSW index

Load the table into a DataFrame

python

def load_table(sample_size='*') -> pd.DataFrame:
    sql = f"SELECT * FROM SQLUser.SamplePoetry{f' LIMIT {sample_size}' if sample_size != '*' else ''}"
    result_set = iris.sql.exec(sql)
    df = result_set.dataframe()
    # Entries without text will not be vectorized nor searchable
    for index, row in df.iterrows():
        if row['poem'] == ' ' or row['poem'] is None:
            df = df.drop(index)
    return df

This uses the dataframe() method of the Embedded Python SQLResultSet object. The optional sample_size argument is for testing. Rows without text are excluded from vector search rather than given a null or empty vector. That helps with datasets where not every row has data in every column, such as survey responses with skipped questions.

Generate embeddings

objectscript

The method returns the embedding as a string because TO_VECTOR expects its data argument to be a string by default. The same method is later reused to embed search queries.ClassMethod GetEmbeddingString(aurg As %String) As %String [ Language = python ]
{
  import iris
  import ollama
  response = ollama.embed(model='all-minilm',input=[ aurg ])
  embedding_str = str(response.embeddings[0])
  return embedding_str
}

Write embeddings to the table

python

# Write dataframe into new table
print("Loading data into table...")
for index, row in df.iterrows():
    sql = iris.sql.prepare("INSERT INTO SQLUser.SamplePoetryVectors (ID, EMBEDDING) VALUES (?, TO_VECTOR(?, decimal))")
    rs = sql.execute(row['id'], row['embedding'])
print("Data loaded into table.")

Dynamic SQL populates the table row by row. Because EMBEDDING is declared as %Library.Vector, TO_VECTOR converts each embedding string to the native VECTOR datatype on insertion.

Create the HNSW index

python

# Create Index
iris.sql.exec("CREATE INDEX HNSWIndex ON TABLE SQLUser.SamplePoetryVectors (EMBEDDING) AS HNSW(Distance='Cosine')")
print("Index created.")

When an HNSW index is created on a compatible column, IRIS natively builds an HNSW graph. The vector search methods are VECTOR_DOT_PRODUCT and VECTOR_COSINE. Once the index exists, IRIS automatically uses it to optimize the corresponding method in later queries. The HNSW defaults are Distance = Cosine, M = 16, and efConstruction = 200.

VECTOR_COSINE implicitly normalizes its input vectors, so embeddings do not need to be normalized before insertion for queries to be scored correctly.

Step 3: Implement VectorSearch()

  1. Generate an embedding for the query string by reusing GetEmbeddingString:

python

# Generate embedding of search parameter
search_vector = iris.cls(__name__).GetEmbeddingString(aurg)
  1. Run a query that ranks results with VECTOR_COSINE. The JOIN combines each poem’s text with its embedding so results are ordered by semantic similarity:

python

# Prepare and execute SQL statement
stmt = iris.sql.prepare(
        """SELECT top 5 p.poem, p.title, p.author 
        FROM SQLUser.SamplePoetry AS p 
        JOIN SQLUser.SamplePoetryVectors AS v 
        ON p.ID = v.ID 
        ORDER BY VECTOR_COSINE(v.embedding, TO_VECTOR(?)) DESC"""
)
results = stmt.execute(search_vector)
  1. Format the output with pandas for the IRIS Terminal:

python

Good to knowresults_df = pd.DataFrame(results)
pd.set_option('display.max_colwidth', 25)
results_df.rename(columns={0: 'Poem', 1: 'Title', 2: 'Author'}, inplace=True)
print(results_df)
  • iris is the InterSystems IRIS Python Module. It is the API for accessing IRIS classes and methods and for working with the database

  • SQLUser is the system-wide default SQL schema, which corresponds to the default package User

Links

If you’re adding semantic search to existing IRIS tables, do you generate embeddings locally with something like Ollama or call a hosted embedding API? And how do you handle rows that have no text?


r/intersystems • • Sep 28 '26

Time to vote in the InterSystems Programming Contest: Build Your Own Management Portal

1 Upvotes

🗳️ The contest projects are in — now it’s time to choose your favorites.

Explore the submissions for “Build Your Own Management Portal” programming contest and see how developers approached #InterSystemsIRIS management tasks through their apps and interfaces. 

Support the solutions you like most in the Community Nomination and follow the daily leaderboard updates on the Developer Community.

📅 Voting: September 28 - October 4, 2026

👉 Explore the apps and cast your vote: https://community.intersystems.com/post/time-vote-intersystems-programming-contest-build-your-own-management-portal 


r/intersystems • • May 12 '25

What is InterSystems OMOP?

1 Upvotes

📽️ Watch this #video to learn how u/InterSystems OMOP simplifies clinical data transformation for faster insights:

✅ Build research data repositories efficiently

✅ Seamlessly ingest, transform, and store data

https://community.intersystems.com/post/video-what-intersystems-omop

Check out this #cloud-based solution!


r/intersystems • • Aug 06 '26

IRIS FHIR Agents: How to Build Multi-Agent Clinical AI Applications on InterSystems IRIS for Health

1 Upvotes

In this article, I will introduce IRIS FHIR Agents, a multi-agent clinical AI platform built on InterSystems IRIS for Health.

IRIS FHIR Agents demonstrates how InterSystems IRIS for Health can serve as the data, interoperability, analytics, and vector-search foundation for a multi-agent clinical AI application. The platform combines conversational triage, specialist consultation, medication safety, live vital-sign monitoring, FHIR server exploration, and a no-code Agent Builder, all working directly on top of a live FHIR R4 server.

What is IRIS FHIR Agents?

IRIS FHIR Agents is a multi-agent healthcare AI application where specialized LangChain-powered agents work together to solve different clinical tasks.

Every request first passes through a routing agent that determines which specialist should handle it. Depending on the conversation, the platform can:

  • perform patient triage

  • analyze medical conditions

  • detect medication interactions and allergy conflicts

  • recommend specialist referrals

  • monitor live patient vitals

  • retrieve clinical guidelines using InterSystems IRIS Vector Search

  • query live FHIR resources

  • create structured FHIR resources

  • deploy custom clinical agents without writing code

Although users interact with a single chat interface, several AI agents may collaborate behind the scenes. 

Platform Architecture

The application is built around five major components:

  • Triage Chat

  • Analytics Dashboard

  • Live Vitals Monitor

  • FHIR Server Agent

  • Agent Builder

At the center of the application is a routing agent that decides which specialist should answer each request. 

InterSystems IRIS provides the foundation for the entire application, combining FHIR interoperability, Embedded Python, SQL analytics, and Vector Search within a single platform.

Clinical AI Features

Multi-Agent Orchestration

Instead of asking one LLM to perform every task, I divided responsibilities across multiple specialized agents.

The platform currently includes:

  • Triage Agent

  • Specialist Agent

  • Pharmacy Agent

  • FHIR Server Agent

Each conversation begins with an LLM router that automatically dispatches requests to the appropriate agent. Users never need to select an agent manually.

Retrieval-Augmented Generation with IRIS Vector Search

To improve the quality of clinical recommendations, I integrated InterSystems IRIS Vector Search. 

The platform stores 50 clinical guidelines as vector embeddings and retrieves the most relevant passages using VECTOR_COSINE similarity search before generating a response. This allows recommendations to be grounded in trusted medical guidance instead of relying solely on the language model.

Native FHIR Integration

Every agent works directly with a live InterSystems IRIS FHIR server.

The platform retrieves information such as:

  • Patients

  • Conditions

  • Medications

  • Allergies

  • Observations

Agents can also create structured FHIR resources, including:

  • Observation

  • ServiceRequest

  • MedicationRequest

This means the AI doesn't simply generate text—it can produce structured clinical data using standard FHIR resources.

Walking Through the Application

Triage Chat

The Triage Chat is the primary interface for interacting with the platform.
A clinician or patient simply describes symptoms in natural language. Behind the scenes, the routing agent selects the appropriate specialist, retrieves the patient's clinical context from the FHIR server, and generates a response grounded in relevant guidelines.

The interface also displays:

  • the currently active agent

  • urgency level

  • loaded patient context

  • FHIR write counter

  • available custom agents

Patients can be selected from a searchable list loaded directly from the FHIR server, and conversations support both voice input and multiple languages.

Analytics Dashboard

The Analytics Dashboard provides a real-time overview of clinical data stored in IRIS together with an audit trail of AI-generated activity.

It includes:

  • population statistics

  • patient demographics

  • active conditions

  • AI-generated Observations

  • AI-generated ServiceRequests

Because the dashboard reads directly from the FHIR server, every action performed by the agents immediately becomes visible.

Live Vitals Monitor

Live Vitals Monitor demonstrates how AI agents can react automatically to live clinical events. Patient vital signs are streamed every two seconds using Server-Sent Events. Each reading is immediately written to IRIS as a FHIR Observation. Whenever a critical threshold is detected, the platform automatically launches a triage assessment.

The AI assessment appears in real time together with its urgency level and the guideline references used during reasoning.

FHIR Server Agent

FHIR Server Agent combines two complementary interfaces. The first is a conversational assistant that lets me query live FHIR data in natural language. The second is a visual Capability Explorer that reads the server's CapabilityStatement and displays:

  • supported resources

  • interactions

  • search parameters

  • resource categories

  • server capabilities

Because everything is loaded dynamically, the interface always reflects the actual configuration of the connected FHIR server.

Agent Builder

I also wanted to make it easy to extend the platform without modifying the application itself. The Agent Builder provides a no-code interface for creating new clinical agents.

Users can:

  • start from a specialty template

  • define the system prompt

  • select available tools

  • configure temperature

  • enable RAG

  • test against live FHIR data

  • deploy immediately

The project includes templates for Oncology, Cardiology, Geriatrics, Pediatrics, and Nutrition, but new specialties can be added without changing the application code.

Why InterSystems IRIS for Health?

This project brings together several InterSystems technologies that naturally complement AI applications. InterSystems IRIS for Health provides:

  • native FHIR R4 interoperability

  • Embedded Python

  • SQL analytics

  • Vector Search

  • structured healthcare data storage

  • real-time FHIR read and write operations

Using these capabilities together means the application can retrieve patient data, perform semantic search over clinical guidelines, generate AI recommendations, and store structured clinical resources within the same platform.

Key Takeaways

Building IRIS FHIR Agents allowed me to explore how multiple AI agents can collaborate on top of live healthcare data instead of acting as isolated chatbots.

Using InterSystems IRIS for Health, I was able to combine FHIR interoperability, Vector Search, Embedded Python, analytics, and AI into a single platform that can retrieve patient data, ground recommendations in clinical guidelines, monitor live patient events, and create structured FHIR resources.

While this project is a demonstration, it illustrates how InterSystems IRIS can provide the foundation for multi-agent healthcare applications that move beyond conversation and interact directly with real clinical workflows. 

Frequently Asked Questions

What is IRIS FHIR Agents?

IRIS FHIR Agents is a multi-agent clinical AI platform built on InterSystems IRIS for Health. It combines patient triage, specialist consultation, medication safety, live vital-sign monitoring, FHIR server exploration, and a no-code Agent Builder. All agents work directly with a live FHIR R4 server and can retrieve or create structured clinical data.

How does the multi-agent architecture work?

Instead of relying on a single AI assistant, the platform uses multiple specialized agents. Every user request is first analyzed by a routing agent, which automatically selects the most appropriate specialist agent—such as the Triage Agent, Specialist Agent, Pharmacy Agent, or a custom agent created through the Agent Builder.

How is InterSystems IRIS Vector Search used?

The platform stores clinical guidelines as vector embeddings in InterSystems IRIS and retrieves the most relevant passages using semantic similarity (VECTOR_COSINE). These guidelines are then included in the AI prompt, allowing the agents to generate responses grounded in trusted medical guidance rather than relying solely on the language model.

Does the application work with live FHIR data?

Yes. The application connects directly to a live InterSystems IRIS FHIR R4 server. The agents can retrieve patient information, conditions, medications, allergies, observations, and other FHIR resources in real time.

Can the AI agents write data back to the FHIR server?

Yes. In addition to reading clinical data, the agents can create structured FHIR resources such as Observation, ServiceRequest, and MedicationRequest. This allows AI-generated recommendations and clinical events to become part of the patient's structured healthcare record.


r/intersystems • • Sep 30 '26

InterSystems IRIS AI Hub: building and governing AI agents within one data platform

1 Upvotes

Getting an AI agent to call an LLM is relatively straightforward. The tricky part starts when that agent needs access to enterprise data, permission to execute business logic, integration with external systems, and a governed way to operate in production.

InterSystems IRIS AI Hub is designed to meet that production layer. It provides capabilities for building, deploying, and governing AI agents and agentic workflows directly within IRIS and IRIS for Health, so agents can work with enterprise data, business logic, security controls, and operational workflows.

One of the key pieces is native Model Context Protocol support. MCP works bidirectionally:

  • IRIS data, functionality, and business processes can be exposed as governed MCP tools to external AI frameworks.

  • AI Hub agents can connect to third-party MCP servers and enterprise tools such as Jira, Salesforce, Workday, and other services.

For workflows that require human involvement, IRIS Interoperability can be used to add approval steps and human-in-the-loop oversight directly into agentic workflows. 

This means the same platform can provide:

  • enterprise data access

  • business logic

  • MCP-based tool integration

  • security and governance

  • human approval workflows

  • deployment alongside existing applications

The goal is to move AI agents from pilot to production by bringing data access, governance, and operational workflows into the same environment.

The full article covers the AI Hub architecture, MCP integration, governance model, and how it fits into IRIS development and DevOps workflows: https://community.intersystems.com/post/intersystems-iris-ai-hub-build-connect-and-govern-ai-agents 


r/intersystems • • 29d ago

How do you create, read, and modify JSON in InterSystems IRIS? A practical guide to %DynamicObject, %DynamicArray, and Embedded Python

1 Upvotes

JSON in InterSystems IRIS is handled natively through dynamic entities. This guide covers how to build them, how to read and change values, and which behaviors tend to cause confusion.

Three ways IRIS works with JSON

  1. JSON literal constructors in ObjectScript syntax

  2. %DynamicObject and %DynamicArray classes with their serialization and deserialization APIs

  3. SQL functions JSON_OBJECT, JSON_ARRAYAGG, and JSON_TABLE

This article covers the first two. The literal constructor {} creates a %Library.DynamicObject, and [] creates a %Library.DynamicArray.

Creating an object: three methods

// 1. Literal. Values in parentheses are evaluated at runtime
Set json = {"name":"test,patient","p_age":($H - $ZDateH("12/01/1990") \ 365),"isActive":true}
// 2. Step by step
Set json = {}
Set json.name = "test,patient"
// 3. With %Set(key, value, type)
Set json = {}
Do json.%Set("p_age",  ($Horolog - $ZDateH("12/01/1990") \ 365), "number")
Do json.%Set("IsActive",1,"Boolean")

Creating an array

Set array = [1, "test", 12.32565, {"name": "test"}, ($ZVersion), true]
Set array = []
Do array.%Push(1)
Do array.%Push({"name": "test"})
Assigning by index leaves gaps. They display as null when serialized, but they are not really null:
USER>Set array = []
USER>Set array."1" = "test"
USER>Set array."5" = "hello"
USER>Write array.%ToJSON()
[null,"test",null,null,null,"hello"]
array.%GetTypeOf(0) returns "unassigned".

Reading values with %Get(key, default, type)

By default, JSON values are converted to ObjectScript values. The third argument controls that:

For strings longer than the maximum string length (3,641,144), use "stream" to avoid a <MAXSTRING> error. The result is a read-only %Stream.DynamicCharacter or %Stream.DynamicBinary. To modify it, copy it into a writable stream with CopyFrom().USER>Set json = {"IsActive": true, "IsNull": null}
USER>Write json.%Get("IsActive") ; returns 1
1
USER>Write json.%Get("IsActive",,"JSON") ; returns true
true
USER>Write json.%Get("IsNull", , "JSON") ; returns null
null
Other type values: "string", "string>base64", "string<base64", "stream", "stream>base64", "stream<base64", "json".

Writing values with %Set(key, value, type)

  • Boolean: Do json.%Set("active", 1, "Boolean") gives {"active":true}

  • Number from a string: Do json.%Set("int", "158425", "Number")

  • Null: Do json.%Set("IsNull", "", "null")

  • Base64: "string>base64" encodes, "string<base64" decodes

  • Streams: "stream", "stream>base64", "stream<base64"

Other methods

  • %IsDefined(key): returns 1 or 0, case-sensitive

  • %Remove(key): deletes the element and returns its value

  • %Size(): number of elements

  • %Set() and %Push() return chainable references:

USER>Set jstring = "[123]"
USER>Write [].%FromJSON(jstring).%Set(1,"one").%Push("two").%Push("three").%Set(1,"final value").%ToJSON()
[123,"final value","two","three"]

$Property is generally more efficient than $Method for accessing values in %DynamicObject instances.

Behaviors worth knowing

  • Numbers: literal constructors preserve trailing zeros and scientific notation. {"decimal":1.00000} stays 1.00000. JSON numbers can exceed ObjectScript's range: SET z=[3E400] works, but z.%Get(0) signals <MAXNUMBER>

  • Unicode: "\u00E9" in a literal is parsed as ĂŠ. ("cach\u00E9") in parentheses is an ObjectScript expression, so the escape stays as \\u00E9

  • Comments: /* */ block comments are allowed inside constructors. // line comments are not allowed inside single-line declarations

Embedded Python

In Embedded Python, use _ instead of % for IRIS methods (%Get becomes _Get). Native Python equivalents are also available:

ObjectScriptEmbedded Python
%Get_Get or get
%Set_Set or put
%IsDefinedcontains
%Remove_Remove or remove
%Sizesize
%ToJSONtoString

import iris

dynObject1 = iris._Library.DynamicObject._New()
dynObject1._Set("MRN",298598)
dynObject1._Set("IsActive", 1, "boolean")
IRIS 2025.1 supports the shorter iris._Library.DynamicObject._New() instead of iris.cls("%DynamicObject")._New().

Full article: https://community.intersystems.com/post/intersystems-iris-json

The remaining methods are covered in part two of the series.

Which of these has caught you out most often in real code: true and null flattening in %Get, unassigned array elements, or <MAXSTRING> on large strings?


r/intersystems • • Oct 21 '26

Troubleshooting %DynamicObject in InterSystems IRIS: 7 Common Pitfalls

1 Upvotes

In an HL7 interoperability production, a BPL Business Process can extract information from an incoming message and store it in a %DynamicObject for use in routing decisions.

Problems arise when the Business Process reads these properties incorrectly. For example, a misspelled property name or incorrect access to a nested object may return an empty value without producing an error. As a result, the routing rule evaluates the wrong value, fails to match the expected condition, and moves to another rule or the default action.

The following seven examples explain common %DynamicObject pitfalls, why they occur, and how to avoid them.

1. Property Names with Underscores

This is the most common silent failure when consuming REST APIs that use snake_case naming. When you write the following: 

Set val = dynObj.patient_id 

ObjectScript does not read patient_id as a single property name. The underscore _ is the string concatenation operator, so this line is read as the value of dynObj.patient concatenated with the string id. Since dynObj.patient does not exist, the result is empty, with no error or warning. 

For example:

// Wrong - returns empty silently
Try {
    Set val = dynObj.patient_id
} Catch ex {
    Set val = ""
}
// Correct - use %Get() for underscore-named properties
Set val = dynObj.%Get("patient_id") 

This is particularly relevant when working with JSON from REST APIs that use snake_case property names.

2. Case-Sensitive Property Names

%DynamicObject  property names are case-sensitive. For example, patient_id, Patient_Id, and PATIENT_ID represent different properties.

// Wrong - wrong case returns empty silently
Set val = dynObj.%Get("Patient_Id")

// Correct - exact case must match what was set
Set val = dynObj.%Get("patient_id") 

A mismatch in capitalization can return an empty value without indicating that the wrong property name was used. Check the original JSON and make sure the property name matches exactly.

3. Accessing Nested Objects

Nested JSON objects become separate %DynamicObject instances. Dot notation does not automatically traverse these nested objects.

Suppose your metadata includes an "address" object containing a "city" property.

// Wrong - fails silently
Set city = dynObj.address.city
// Correct - get the nested object first, then access its property
Set addr = dynObj.%Get("address")
Set city = addr.%Get("city") 
For deeper structures, retrieve each nested object in sequence:
Set patientObj = dynObj.%Get("patient")
Set contactObj = patientObj.%Get("contact")
Set phone      = contactObj.%Get("phone") 

This approach makes each level of the JSON structure explicit.

4. Checking Whether a Property Exists

Using %Get() alone is not a reliable way to check for the existence of a property. A property might be missing entirely or might exist with an empty value. Both situations can produce an empty result when using %Get().

In the Event Log, you will see ward_code logged as "does not exist" because we never set it, while patient_id is correctly found and returned. Use %IsDefined when you need to distinguish a missing property from one that exists but contains an empty value. // Wrong - cannot distinguish missing property from empty value
If dynObj.%Get("patient_id") = "" {
    // Is it missing or just empty?
}
// Correct - explicitly checks if property exists
If dynObj.%IsDefined("patient_id") {
    Set val = dynObj.%Get("patient_id")
} Else {
    $$$LOGINFO("patient_id does not exist - using default")
    Set val = "UNKNOWN"
} 

5. Iterating Over %DynamicObject Properties

An indexed ObjectScript For loop does not enumerate %DynamicObject properties as object keys. Instead, use %GetIterator().

// Wrong - does not work on %DynamicObject
For i = 1:1:dynObj.%Size() {
    Write dynObj.%Get(i), !
}
// Correct - use %GetIterator()
Set iter = dynObj.%GetIterator()
While iter.%GetNext(.key, .val) {
    If $IsObject(val) {
        $$$LOGINFO("Key: " _ key _ " = [object]")
    } Else {
        $$$LOGINFO("Key: " _ key _ " = " _ val)
    }
} 

%GetIterator() lets you retrieve each property name and its value. If a property contains a nested object, the example identifies it as[object]rather than displaying its contents. The same method also works with %DynamicArray, returning numeric indices starting from zero instead of property names.

6. Distinguishing JSON Null from an Empty String

A JSON property containing null is different from one containing an empty string (""). However, reading either value through %Get() can produce an empty result.

Use %GetTypeOf() when you need to identify the underlying JSON type.

Set testObj = ##class(%DynamicObject).%FromJSON("{""nullProp"":null,""emptyProp"":""""}")
// Both return empty from %Get()
Write testObj.%Get("emptyProp"), !   // empty
Write testObj.%Get("nullProp"), !    // empty
// Use %GetTypeOf() to distinguish
Write testObj.%GetTypeOf("emptyProp"), !  // string
Write testObj.%GetTypeOf("nullProp"), !   // null 

%GetTypeOf() can identify types including "string", "number", "boolean", "null", "object", or "array". Use it whenever you need to make a decision based on what type of value a property holds rather than just whether it is empty or not. 

7. Comparing JSON Numbers with Strings

When JSON contains numeric values, %DynamicObject stores them as numbers rather than strings. Comparing a numeric property with a string can result in a condition that does not match.

Set numObj = ##class(%DynamicObject).%FromJSON("{""age"":25}")
// Wrong - string comparison does not match a numeric value
If numObj.%Get("age") = "25" { ... }
// Correct - use numeric comparison
If numObj.%Get("age") = 25 { ... }
// Also correct - force numeric conversion with unary +
If +numObj.%Get("age") = 25 { ... } 

When working with numeric JSON values, use numeric comparisons or the unary + operator for explicit conversion.

Conclusion

%DynamicObject provides a way to store and access dynamic metadata in InterSystems IRIS Business Processes, but incorrect property access can be difficult to diagnose when routing conditions receive empty or unexpected values. Using %Get() consistently, checking property existence and types, and logging values during development can help identify these issues before they affect routing decisions.

🔎 Read the full guide by @Muhammad Waseem:

https://community.intersystems.com/post/business-rules-deep-dive-dynamic-objects-and-property-access-pitfalls-part-2-0

Key Takeaways

  • Prefer %Get() for %DynamicObject property access, especially when working with JSON property names containing underscores or nested structures.

  • Property names are case-sensitive. Verify their exact spelling and capitalization.

  • Use the appropriate methods for different checks: %IsDefined for property existence, %GetTypeOf() for value types, and %GetIterator() for enumeration.

  • Respect JSON value types when evaluating routing conditions, particularly numeric values.

  • Check actual values in the Event Log and Visual Trace when troubleshooting unexpected routing decisions.


r/intersystems • • Aug 19 '26

[Release notes] InterSystems IRIS, InterSystems IRIS for Health, and InterSystems Health Connect 2026.2 Are Now Generally Available

1 Upvotes

The 2026.2 release of InterSystems IRIS data platform, InterSystems IRIS for Health, and InterSystems Health Connect is now Generally Available (GA). This is a Continuous Delivery (CD) release.

What's New in InterSystems IRIS 2026.2?

InterSystems IRIS 2026.2 introduces improvements across SQL, Business Intelligence, interoperability, FHIR tooling, database operations, and developer productivity. Highlights include Common Table Expressions (CTEs) in stored procedures, a new FHIR Explorer, continued enhancements to the new Interoperability user interface, and performance improvements for database migration and FHIR ingestion.

SQL and Data Management

This release introduces Common Table Expressions (CTEs) inside stored procedures, making it easier to write more readable and maintainable SQL logic.

Improvements around table partitioning:

  • Enhanced ALTER TABLE ... MOVE PARTITION behavior.

  • Fixes for partition keys using uppercase field names.

Business Intelligence

InterSystems IRIS BI can now use SQL foreign key relationships when defining analytical models. This makes it easier to build BI models directly from operational databases where relationships are already defined using relational constraints.

Database Operations

The cvendian migration utility has been optimized to improve database conversion performance between big-endian and little-endian platforms. Depending on the workload, conversion times can be up to twice as fast, and interrupted conversions now provide clearer error reporting.

Interoperability

The new Interoperability user interface continues to evolve with improvements across:

  • Production Configuration

  • Message Viewer

  • Message Search

  • Visual Trace

  • DTL Editor

  • BPL Editor

  • Schema Viewer

  • Rule Editor

The new experience remains opt-in for existing deployments, and the InterSystems team continues to encourage community feedback.

FHIR Explorer

InterSystems IRIS for Health 2026.2 introduces FHIR Explorer, a new tool for building, testing, and exploring FHIR requests against IRIS for Health and third-party FHIR endpoints. It uses Capability Statements from EHR endpoints and FHIR servers to help users build complex requests, test security configurations, and discover available capabilities with IntelliSense-style suggestions.

FHIR Server Enhancements

Several improvements have been made to FHIR interoperability and server behavior, including:

  • Support for generic application/json and application/xml media types in addition to FHIR-specific content types.

  • Search paging with _include and _revinclude can now return included resources on the same page as their matched result, with an option to retain the previous behavior.

  • Direct Binary resource responses when the requested Accept header matches the stored content.

  • Configurable OAuth Audience validation for tokens issued by providers such as Entra ID, Okta, and Amazon Cognito.

  • Optional structural validation bypass during bulk FHIR ingestion when alternative data validation processes are already in place. For large migration workloads, ingestion optimizations can improve FHIR import performance by 25-30% in some scenarios.

Is there anything to review before upgrading to 2026.2?

Yes. The Apache UIMA integration, which was deprecated in 2023.1, has now been removed from InterSystems IRIS. Applications that still reference UIMA should review those code paths before upgrading to 2026.2.

Key Takeaways

  • InterSystems IRIS 2026.2 adds support for Common Table Expressions (CTEs) in stored procedures.

  • InterSystems IRIS BI now supports SQL foreign key relationships in analytical models.

  • Database migration performance has improved through updates to the cvendian utility.

  • The new Interoperability user interface continues to expand across multiple development tools.

  • FHIR Explorer provides a new way to build and test FHIR requests against IRIS for Health and third-party FHIR servers.

  • FHIR server enhancements include improved media type handling, paging behavior, OAuth validation, and ingestion performance.

  • Customers upgrading should review applications that still depend on the removed Apache UIMA integration.

Learn more here

FAQ

What is the biggest new SQL feature in InterSystems IRIS 2026.2?

InterSystems SQL now supports Common Table Expressions (CTEs) inside stored procedures, enabling more expressive and maintainable SQL logic.

What is FHIR Explorer?

FHIR Explorer is a new tool in InterSystems IRIS for Health that helps developers build, test, and explore FHIR requests using Capability Statements and IntelliSense-style suggestions.

Does InterSystems IRIS 2026.2 improve FHIR performance?

Yes. For some large migration scenarios, FHIR ingestion optimizations can improve import performance by approximately 25–30%.

Is the new Interoperability UI enabled by default?

No. The updated Interoperability experience remains opt-in for existing customers.

Is there a breaking change in this release?

Yes. Apache UIMA integration has been removed. Applications that still depend on it should be reviewed before upgrading.


r/intersystems • • Sep 10 '26

[Release notes] InterSystems AI Hub Early Access

1 Upvotes

Summary

InterSystems AI Hub gives IRIS developers a common way to build AI agents, connect to LLMs, expose IRIS capabilities through MCP, and manage credentials securely. The latest Early Access build is now available.

InterSystems AI Hub is an AI development layer for InterSystems IRIS that helps developers build agents, connect LLMs, expose IRIS capabilities through MCP, and manage credentials and access controls without assembling the full stack manually. 

A new Early Access build is now available with updated kits and containers, plus a dedicated Discord channel for questions and discussion.

What does AI Hub include?

  • AI SDK for ObjectScript and Python/LangChain developers to build agents, connect to LLMs, and manage tools using IRIS-native abstractions.

  • MCP Server to expose existing IRIS code, SQL queries, FHIR endpoints, and Business Services as tools for MCP-compatible agents.

  • Config Store + IRIS Wallet for centralized management of LLM credentials and provider configuration.

The goal is to keep the AI integration layer governed by IRIS security and RBAC while reducing the amount of plumbing developers need to build themselves.

What’s new?

A fresh prerelease build is now available through the Evaluation Portal with a broad set of fixes and improvements.

There is also now a dedicated AI Hub EAP Discord channel for real-time questions, discussion, and sharing what you are building. GitHub Issues remain the preferred place for bugs and feature requests.

Conclusion

The new Early Access build is a good point to start experimenting with InterSystems AI Hub if you want to connect AI models and agents more directly to InterSystems IRIS. With the AI SDK, MCP Server, and centralized credential management in one stack, the focus can stay on the application logic rather than on wiring together separate AI components.

Learn more: https://community.intersystems.com/post/intersystems-ai-hub-early-access-new-community-build-discord-channel


r/intersystems • • Oct 06 '26

Winners of the InterSystems Programming Contest: Build Your Own Management Portal

1 Upvotes

🏆 Ever wondered what a fresh, modern GUI for the Management Portal could look like? The winners of the InterSystems Programming Contest: Build Your Own Management Portal answered that challenge by bringing their unique visions to life!

​Out of 37 incredible applications, the top projects went far beyond simple screen redesigns to completely reimagine the IRIS administration experience. Here’s a look at what developers built:

  • Agent-assisted operations — bringing AI into the portal to understand the current screen, answer questions about live data, and propose administrative changes with user confirmation and auditing.

  • Visual task orchestration — turning maintenance jobs into connected workflows with parallel steps, dependencies, scheduling, and live execution tracking.

  • Lighter portal architectures — working directly with the official SysAdmin REST API, including approaches with no separate application server or almost no custom backend.

  • Operations and observability in one place — combining system health, logs, security, REST APIs, tasks, permissions, and diagnostics into unified operational consoles. Some projects also brought in Embedded Python and IRIS Vector Search for health scoring, log analysis, and recommendations.

  • Managing beyond a single instance — including tools designed to monitor and operate multiple independent IRIS instances from one workspace.

The result was a broad look at how the same IRIS management APIs can support very different ideas around administration, monitoring, security, and developer experience.

👏 Congratulations to all the winners and participants!

👉 Explore the full results and projects: https://community.intersystems.com/post/winners-intersystems-programming-contest-build-your-own-management-portal 


r/intersystems • • Feb 15 '19

How to Develop InterSystems Applications in Your Favorite IDE

Thumbnail
community.intersystems.com
1 Upvotes

r/intersystems • • Feb 15 '19

How to install and use TFS in Atelier

Thumbnail
community.intersystems.com
1 Upvotes