DEV Community: Roshan Sanjeewa Wijesena

How to Customize Stubborn Chart Colors in Boomi Flow Using CSS Filters

Roshan Sanjeewa Wijesena — Tue, 10 Mar 2026 00:48:07 +0000

If you build dashboards in Boomi Flow, you know how powerful its charting components can be. Powered by Chart.js under the hood, it’s usually straightforward to get a good-looking dashboard up and running. But what happens when you need two charts on the same page—like a Donut Chart and a Bar Chart—to use completely different color palettes, and the platform refuses to cooperate?

If you’ve tried overriding the --color-chart CSS variables only to watch both charts stubbornly share the exact same global colors, you aren't alone. Here is a breakdown of why this happens and the CSS "hack" you need to fix it.

The Problem: The Global Variable Trap
In Boomi Flow, chart colors are typically controlled by a set of CSS variables (e.g., --color-chart-1, --color-chart-2) attached to a high-level .flow class.

When you place a Bar Chart and a Donut Chart on the same page, they both act as children of this .flow parent. Even if you wrap each chart in a custom

(like .mizuho-barchart and .mizuho-donut) and try to assign unique variables to those classes, Boomi's engine often bypasses your local CSS. Instead, the JavaScript engine jumps straight to the root .flow class, grabs the global color palette once, and paints both canvas elements with the exact same brush.

The Solution: The Canvas Filter Hack
Because the charts are rendered onto an HTML , they are essentially flattened images once drawn. Standard CSS variables can't easily change pixels that are already painted.

Instead of fighting the JavaScript engine for control of the CSS variables, we can let Boomi paint both charts with the same global palette, and then use CSS filter properties to visually shift the colors of the second chart post-render.

Here is how you do it:

Step 1: Set Your Base Palette
First, define the global CSS variables for your primary chart (in this case, the Donut Chart). We will use a clean, professional palette of Dark Navy, Coral, Teal, and Medium Blue.

CSS
/* 1. BASE PALETTE (This colors the Donut Chart) /
.flow {
--color-chart-1: #033d58 !important; / Dark Navy /
--color-chart-2: #ff7c66 !important; / Coral /
--color-chart-3: #22c5be !important; / Teal /
--color-chart-4: #4a8bd6 !important; / Medium Blue */
}
Step 2: Override the Second Chart with hue-rotate
Next, we target the specific container for the second chart (the Bar Chart) and apply a CSS filter directly to its canvas.

The hue-rotate() filter pushes the original colors across the color wheel. We can combine this with saturate and brightness to fine-tune the resulting color so it looks entirely distinct from the Donut Chart.

CSS
/* 2. BAR CHART OVERRIDE (Dramatically shifts the colors) /
.mizuho-barchart canvas {
/ hue-rotate(120deg) shifts the Navy base to a rich Emerald Green.
saturate(1.2) keeps it punchy.
brightness(1.1) lightens it slightly.
*/
filter: hue-rotate(120deg) saturate(1.2) brightness(1.1);
}
Adjusting the Formula
Because your Bar Chart is now mathematically linked to the base palette, you can easily change its color profile just by tweaking the degrees:

0deg: Stays Dark Navy (matches the base).

120deg: Emerald Green.

180deg: Warm Bronze.

240deg: Deep Purple.

Conclusion
When working with low-code platforms, you sometimes hit a wall where the underlying JavaScript framework overrides your custom CSS. By treating the rendered as an image and using powerful CSS filters like hue-rotate, you can bypass these limitations and deliver exactly the UI your users (or clients) are asking for.

How to Connect Boomi to ActiveMQ Without Crashing Atom Queues

Roshan Sanjeewa Wijesena — Tue, 24 Feb 2026 02:27:54 +0000

If you are building an integration in Boomi that connects to an external ActiveMQ broker (like version 5.19.x) while also utilizing Boomi’s internal Atom Queues, you might run into a fatal issue: your Atom crashes and refuses to restart.

Here is a breakdown of why this happens and the exact steps to fix it.

The Problem: Classpath Collisions
To connect to an external ActiveMQ broker, Boomi requires the specific ActiveMQ client driver (e.g., activemq-client-5.19.1.jar).

The standard Boomi documentation often suggests dropping custom JAR files directly into the Atom’s userlib or userlib/jms directories. However, if you are also using Atom Queues, this creates a massive problem.

Boomi’s Atom Queues are powered by an embedded version of ActiveMQ. When you enable them, Boomi automatically loads its own internal ActiveMQ JARs into the JVM. When you manually place your new activemq-client JAR into the userlib folder, Boomi tries to load both versions at startup.

The result? A fatal classpath collision (usually a java.lang.NoSuchMethodError or LinkageError). The Atom crashes, and the service will not restart until the conflict is resolved.

The Solution: Connector-Scoped Custom Libraries
To fix this, we need to stop loading the external ActiveMQ JAR globally and instead isolate it so it is only used when your specific JMS Connection is triggered. We do this using Boomi’s Custom Library feature.

Step 1: Resuscitate the Atom
First, you must remove the conflicting file to get your Atom back online.

Navigate to your Atom's installation directory on your server.

Go to the userlib or userlib/jms folder and delete the activemq-client-x.x.x.jar you manually placed there.

Restart your Boomi Atom service. It should now boot up successfully.

Step 2: Upload the JAR via the Platform
Stop putting files directly on the server. Let Boomi manage them.

Log into the Boomi platform.

Navigate to Settings > Account Information and Setup > Account Libraries.

Upload your activemq-client-x.x.x.jar file.

Step 3: Create the Custom Library Component
This is the crucial step where the magic happens.

Go to the Build tab and create a new Custom Library component.

Important: Set the Custom Library Type to Connector (Do not set it to General).

Select your specific JMS Connection from the Connector Type dropdown.

Select the JAR file you uploaded in Step 2 to include it in this library.

Step 4: Deploy
Save the Custom Library component.

Click Create Packaged Component and deploy it to your Atom's environment.

Why This Works
By setting the Custom Library type specifically to Connector, you are telling the Boomi JVM to load that specific activemq-client JAR only when that exact JMS connection is executing.

It keeps the JAR completely hidden from the rest of the Atom, preventing any conflicts with Boomi's internal Atom Queues. Your external connection works flawlessly, and your internal queues keep humming along!

AI Chat-Bot with pinecone vector DB

Roshan Sanjeewa Wijesena — Tue, 21 May 2024 13:02:20 +0000

Vector Databases like pinecode is a good candidate to store your custom data, that you want to use in your next AI application.

In the blog post i will be using pinecone vector database which is easy to use and its a cloud native.

Also i will be using openAI apis as my LLM model.

First get your pinecone API Key - https://app.pinecone.io/organizations/-/projects

You will need openAI API key as well to call openAI models

Install below python libs

!pip install langchain
!pip install pinecone-client
!pip install openai
!pip install pypdf
!pip install tiktoken
!pip install langchain-community
%pip install --upgrade --quiet  langchain-pinecone langchain-openai langchain
from langchain.document_loaders import PyPDFDirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.vectorstores import Pinecone
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
from langchain_community.document_loaders import TextLoader
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import CharacterTextSplitter
import os

We can upload a folder in current workspace and we can upload a any pdf file with your data into that folder. This will be your custom data to train your chat agent

!mkdir pdfs
loader = PyPDFDirectoryLoader("pdfs")
data = loader.load()

Split the loaded data into smaller chunks before inserting into the vector database

text_chunks = text_splitter.split_documents(data)

Set your keys

os.environ["OPENAI_API_KEY"] = "<Key>"

os.environ["PINECONE_API_KEY"] = "<Key>"

Use openAIEmbedding to embedded your texts

embeddings = OpenAIEmbeddings()

Use langchain pineconevectorstore module to store data into the pinecone.
Before that make sure that you have created a new index in pinecone database with a namespace, in my case "roshan"

from langchain_pinecone import PineconeVectorStore
index = "vectorone"
docsearch = PineconeVectorStore.from_documents(text_chunks, embeddings, index_name=index,namespace='roshan')

Now you check your pinecone database you should be able to see data

You can run your query to ask questions around your uploaded pdf data

docsearch.as_retriever()
query = "what is Scaled Dot-Product Attention?"
docs = docsearch.similarity_search(query)
llm = OpenAI(temperature=0)
qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=docsearch.as_retriever())
qa.run(query)

You can simply build small commandline chatbot to see how its working.

import sys
while True:
  user_input = input(f"Input Prompt:" )
  if user_input == "exit":
    sys.exit()
  if user_input == '':
    continue
  result = qa.run({'query': user_input})
  print(result)

How to run LLM modal locally with Hugging-Face 🤗

Roshan Sanjeewa Wijesena — Fri, 17 May 2024 05:22:44 +0000

Welcome Back - In this topic i would like to talk about how to download and run any LLM modal into your local machine/environment.

We again use hugging-face here 🤗. You would need hugging-face API key first.

Run below code to download google/flan-t5-large in to your local machine, it will take a while and you will see the progress in your jupyter notebook.

from langchain.llms import HuggingFacePipeline
import torch
from transformers import pipeline,AutoTokenizer,AutoModelForCausalLM,AutoModelForSeq2SeqLM
model_id= "google/flan-t5-large"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForSeq2SeqLM.from_pretrained(model_id)

pipe = pipeline("text2text-generation", model=model, tokenizer=tokenizer,max_length=128)
local_llm = HuggingFacePipeline(pipeline=pipe)

prompt = PromptTemplate(
    input_variables=["name"],
    template="Can you tell me about footballer {name}",
)
chain = LLMChain(prompt=prompt, llm=local_llm)
chain.run("messi")

How to run any LLM model with Hugging-Face 🤗

Roshan Sanjeewa Wijesena — Fri, 17 May 2024 04:44:59 +0000

Hugging-face 🤗 is a repository to host all the LLM models available in the world. https://huggingface.co/

If you go to the models sections of the repo, you would see thousands of models available to download or use as it is.

Let's get an example to use google/flan-t5-large to generate text2text prompts

Install below python libs

!pip install huggingface_hub
!pip install transformers
!pip install accelerate
!pip install bitsandbytes
!pip install langchain

Get a huggingface API Key - https://huggingface.co/settings/tokens
You can run below python code now with your Key

from langchain import PromptTemplate, HuggingFaceHub, LLMChain
import os
os.environ["HUGGINGFACEHUB_API_TOKEN"] = "<HUGGINGFACEKEY>"
prompt = PromptTemplate(
    input_variables=["product"],
    template="What is the good name for a company that makes {product}",
)

chain = LLMChain(prompt=prompt, llm=HuggingFaceHub(repo_id="google/flan-t5-large",model_kwargs={"temperature":0.1, "max_length":64}))

chain.run("fruits")

Results from Model = Fruits is a footballer from the United States.

Google Search with Langchain

Roshan Sanjeewa Wijesena — Wed, 15 May 2024 07:14:52 +0000

Do you ever want to hook google search API into your GenAI application? you don't need to pay for wrapper services like serpapi, We have langchain wrapper langchain-google-communityfor Google search API and its free.

You need to get Google API Key - https://developers.google.com/custom-search/v1/introduction(https://developers.google.com/custom-search/v1/introduction)
Install below python packages in your env

!pip install langchain
!pip install -U langchain-google-community

3 Set your google api key

import os
os.environ["GOOGLE_API_KEY"] = "<YOUR_API_KEY>"

4 Below code will help you to search google

from langchain_google_community import GoogleSearchAPIWrapper
from langchain_core.tools import Tool
import os

import inspect

# Get the constructor of GoogleSearchAPIWrapper
constructor = inspect.signature(GoogleSearchAPIWrapper)

# Print the number of parameters it expects
print(f"Number of parameters expected: {len(constructor.parameters)}")

api_key = os.environ.get("GOOGLE_API_KEY")

search = GoogleSearchAPIWrapper()

# Create a Tool object using the GoogleSearchAPIWrapper instance
tool = Tool(
    name="Google Search",
    description="Search Google for recent results.",
    func=search.run,
)

# Use the tool to perform a search
results = tool.run("What is the capital of France?")

print(results)

Advance Function Call With Open AI

Roshan Sanjeewa Wijesena — Tue, 14 May 2024 10:27:25 +0000

Sometimes you may be wondering can I book a flight using chatGPT or even can I get information about latest flight details for your favourite holiday destination? The simple answer as of today is no. ChatGPT 3.5 has training data up to 2021 sept, hence it does not know any real time informations as is today.

But using openAI APIs we can build an generative AI application call an extra API to get latest information like real time flight details and embedded to our genAI app.

Lets build a GenAI application to get latest flight information from any given destination

You need to acquire openAI API key. - https://platform.openai.com/api-keys
We need python development environment for this application you can use jupyter notebook or my favourite is Google Colab. - https://colab.google/
You need to install below python packages

!pip install openai

Set your OpenAI API Key in to the python application and set function description

import openai
from openai import OpenAI

openAIKey="YOUR_OPENAI_APIKEY"

client = OpenAI(api_key=openAIKey)

function_description = [
    {
        "name": "get_flight_info",
        "description": "Get the next flight from delhi to mumbai",
        "parameters": {
            "type": "object",
            "properties": {
                "from": {"type": "string", "description": "The depature airport e.g DEL"},
                "to": {"type": "string", "description": "The destination airport e.g SYD"},
                "date": {"type": "string"},
            },
            "required": ["from", "to"],
        },
    }
]

Now you can define your prompt, this is the real question that would ask by end-user

user_prompt = "When's the next flight from Colombo to Sydney? "

Now you need to call openAPI to grab origin and destination air ports from user prompt

response2 = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {
            "role": "user",
            "content": user_prompt
        }
    ],  
    #Add function calling
    functions=function_description,
    function_call="auto" # specify the function call

)
origin = json.loads(response2.choices[0].message.function_call.arguments).get("from")
destination = json.loads(response2.choices[0].message.function_call.arguments).get("to")

This is the fun part, you can build your own function to call real time flight information API, accepting any parameters. For this example, i would mimic sample response from an API.

import json
from datetime import datetime, timedelta
def get_flight_info(from_airport, to_airport):
  """Get Flight information between two airports"""
  #Example out put

  flight_info = {
      "from_airport": from_airport,
      "to_airport": to_airport,
      "date": str(datetime.now() + timedelta(hours=2)),
      "airline" : "Qantas",
      "flight_number": "QF466"
  }
  return json.dumps(flight_info)

Now you pass this function back to openAI API

response3 = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {
            "role": "user",
            "content": user_prompt
        },
        {
            "role": "function",
            "name": "get_flight_info",
            "content": get_flight_info(origin, destination)
        }
    ],  
    #Add function calling
    functions=function_description,
    function_call="auto" # specify the function call

)

response3.choices[0].message.content

The next flight from Colombo (CMB) to Sydney (SYD) is on May 14, 2024, at 11:30 AM. It is operated by Qantas with flight number QF466.

Here is the code - enjoy
https://github.com/rswijesena/AI/blob/3bffb41787c1a5a0110993e305005b0ff990d362/Advance_OpenAI_Function.ipynb

Google Colab With Open AI

Roshan Sanjeewa Wijesena — Sun, 12 May 2024 02:47:48 +0000

Google Colab is a cloud-based Python Jupyter notebook platform, enabling users to execute Python and AI/ML code on Google-hosted CPU/GPU servers. A free version of Google Colab provides access to GPUs for short durations, depending on usage.

By default, Google Colab includes popular ML Python libraries such as PyTorch, yet notably, OpenAI Python libraries are not visible. To address this, users must first install them on their Google Colab environment.

!pip install openai