Artykuł Keycloak Deployment Auditing – General Scope and Guidelines pochodzi z serwisu Inero Software - Software Consulting.

1. What Makes LiveAPI and ElevenLabs a Powerful Combination?

 

LiveAPI solutions such as OpenAI Realtime API and Google Gemini Live API shift the paradigm from static prompts to streaming, interactive communication. These systems support real‑time audio input, low‑latency responses, natural interrupt handling, and multimodal context.

ElevenLabs complements this with industry‑leading voice synthesis. Its realistic, expressive voices and advanced prosody control enable AI agents that sound convincingly human. For telephony environments, this matters — clients expect clarity, confidence, and a pleasant conversational tone.

3. Our Practical Experience Integrating Telephony with LiveAPI and ElevenLabs

Below we outline the key lessons, challenges, and engineering decisions from our implementation.

 

3.1 Project Context

Our client — a large corporate organisation — required a system capable of handling outbound and inbound calls automatically, while maintaining a tone and responsiveness extremely close to human interaction. The goal was not a simple IVR or menu system, but a natural, fully conversational experience driven by real‑time AI.

 

3.2 Technology Stack and Constraints

We evaluated both OpenAI and Gemini Live APIs to compare latency, contextual reasoning and streaming quality. However, due to GDPR compliance requirements, the production system was designed around Gemini Live API. ElevenLabs provided the speech synthesis layer, offering high realism and consistent quality across telephony channels.

3.3 Key Engineering Challenges

Beyond typical engineering concerns like audio quality, session stability, and call routing, the most demanding challenge was not purely technical — it was understanding how real users communicate over the phone. Subtle behaviors such as interruptions, hesitation, changing tone, or switching context required careful analysis and extensive testing.

We also dealt with several micro‑issues, such as premature call termination, incorrect end‑of‑utterance detection, and managing the timing between user speech and AI responses.

 

3.4 What We Built Ourselves

AI models are inherently non‑deterministic and cannot be fully controlled like classic software components. To ensure predictable and business‑aligned outcomes, we developed backend modules responsible for:
• Conversation flow supervision
• Session state tracking
• Monitoring and logging voice interactions
• Handling edge cases and ambiguous user inputs

ElevenLabs’ tooling, especially the Hard Disk service, significantly supported our workflow, but the orchestration layer was built entirely by Inero.

 

3.5 What We Learned

The most important insight: designing a telephony AI system requires deep understanding of the user’s context, combined with the business objectives of the project. Quick prototyping and iterative PoC testing were essential — allowing us to validate conversational patterns early, reveal unexpected user behavior, and refine the interaction design.

Ultimately, success depended on aligning the AI’s conversational style with how real customers naturally speak, pause, and respond during a phone call.

Artykuł Implementing an AI-Powered Telephony Service Center with ElevenLabs & LiveAPI pochodzi z serwisu Inero Software - Software Consulting.

Artykuł Secure Email Delivery in Keycloak 26.2 Using XOAUTH2 pochodzi z serwisu Inero Software - Software Consulting.

Compliance & Risk: Do You Need Full Control Over IAM?

Integration Map: How Many Apps and Protocols Today—and in Two Years?

Team & Operations Capacity: Can You Secure and Run It 24/7 (or Outsource)?

Customization Needs: Themes, Extensions and Advanced Authorization

Scalability & High Availability: What Are Your Peak Loads and DR Needs?

Budget & TCO: What Does Three Years Really Cost vs SaaS?

Vendor Lock‑In & Roadmap Control: How Much Flexibility Do You Need?

Total / Recommendation

Keycloak / SaaS / Hybrid

Artykuł Keycloak or SaaS IdP? A Tech Leader’s Guide to Making the Right IAM Choice pochodzi z serwisu Inero Software - Software Consulting.

Andrzej Chybicki

CEO Inero Software

Keycloak services. Comprehensive implementation, maintenance, and training

Keycloak Performance: Monitoring with Grafana 

Monitoring Keycloak’s performance is crucial, especially in large organizations where the system needs to handle thousands of users simultaneously. Interesting tools to use in this regard if for instance aerogear (https://github.com/aerogear/keycloak-metrics-spi). Aeorgear allows for easy trackick of critical metrics in real-time, allowing for system optimization and scaling. 

Aerogear provides two key functions: MetricsEventListener and MetricsEndpoint, which enable the forwarding of Keycloak events to Prometheus and integration with visualization tools like Grafana. This allows administrators to monitor important metrics, such as: 

• • Memory usage, 

• • Number of logged-in users (by realm, client, globally, etc.), 

• • Login errors. 

Grafana offers a high level of customization, allowing the inclusion of custom parameters (e.g., from CSV files or databases) and setting up alerts. These alerts can be triggered by various factors, such as: 

• • Exceeding login time limits, 

• • Logging in from unauthorized locations, 

• • Unusual numbers of password reset requests. 

Figure 1. Source: grafana.com/grafana/dashboards/10441-keycloak-metrics-dashboard 

Phishing Attack Protection: Adaptive Authentication Mechanisms 

In addition to performance monitoring, Keycloak’s advanced built-in security features help protect against phishing attacks by analyzing event patterns. Keycloak events allow administrators to define custom responses to specific user actions, such as password resets following failed login attempts—often an indicator of phishing activity. 

An example of a security feature is adaptive authentication, which modifies the user login flow based on previous behavior. For instance, if a user requests a password reset without recent failed login attempts, the system could trigger an additional authentication step, like two-factor authentication (2FA). 

Creating and adapting Security Policy 

When implementing these features, it’s essential to determine when user actions should raise suspicion. For example, a password reset without failed login attempts might signal phishing, while a reset after multiple failed logins is more routine. A custom security policy could be defined to say: “If a user requests a password reset without failed logins in the last 3 minutes, require 2FA.” 

These adaptive authentication mechanisms reduce the burden of MFA (multi-factor authentication) while maintaining high security levels. By configuring Keycloak’s event and alert system, organizations can more effectively detect unusual behavior and respond to potential threats more swiftly. 

Keycloak is a versatile tool that supports both performance monitoring and enhanced security. Integration with tools like Grafana allows administrators to keep track of essential system parameters, while advanced event-based mechanisms and adaptive authentication enhance security by protecting against phishing and other threats. Proper configuration of these features can significantly boost security and improve incident response times. 

Artykuł Keycloak: Smart Tips for Monitoring and Protection with Built-in Configuration Tools pochodzi z serwisu Inero Software - Software Consulting.

Artykuł Challenges and Benefits of Integrating Keycloak: Compliance with the NIS 2 Directive and Practical Implementation Advice pochodzi z serwisu Inero Software - Software Consulting.

At Interizon Day 2023 Waldemar Kołub co- founder of Inero Software presented a success story about using Neuronal Networks to optimize the production process.

Farm Frites Poland is leading producer of potato products, supplying products to, among others, one of the largest fast-food restaurants in the world. The company has been operating for over 30 years, and its headquarters is located in Lębork. The modern machinery park consists of three production lines.It employs over 270 people, and the quantity of potatoes used for production over a year exceeds 250,000 tons.

“The problem our client had was to estimate the production yield based on the parameters of the raw input material, so how much of the final product we can obtain from the given amount of the source material, or, to put it in layman’s terms, how much fries we can get from a potato. And it turns out that it is not an easy question to answer.” –  Waldemar Korłub mentioned at his presentation.

Challenges for the development od the company was:

DATA OF THE RAW MATERIAL:

• Contracting for raw material supplies is planned several months in advance and constitutes a significant element of the enterprise’s manufacturing process and pricing policy.
• Estimation of yield, i.e., the difference between the weight of raw material and the final product expressed in percentages (EPY), allows for adjusting the raw material price to the expected result.

PRODUCTION OPTIMIZATION:

• Identification of raw material characteristics that most significantly affect the yield (EPY)?
• Indicate what yield can be expected based on the given raw material?

“So there are a lot of parameters that describe the source material. All in all, there are over 40 different physical traits that need to be taken into account that might influence the final. Yield with the set of parameters. We perform exploratory data analysis to find correlations between the parameters and the final results. By doing that, we are able to identify the parameters which influence the final results the most. Also, we looked for correlations between the parameters which allowed for dimensionality reduction in the problem space and, as a result, it allows for speeding up the machine learning process.”

Machine learning is method used for “feeding” machines with data so that based on this data and their own errors, they learn the rules to solve a given problem. It can be assumed that this is a role reversal, where previously, by defining the rules and utilizing the data, we sought answers.

“With a well-defined set of parameters, we could move on to model research. We’ve tested several different machine learning approaches, including regression models, decision trees, support vector machines, and neural networks. In the end, it turned out that the best results were achieved with neural networks, with the mean error at around 1.2% for the validation data.“

LEARNING

Learning is based on providing training examples (historical data) in the form of:

• Average raw material per run: Green, Rusty, OWG, Color (actual values)
• Average yield per run: EPY (e.g., 45%)

The network minimizes the error between the actual value of EPY (45%) and what it predicts itself (e.g., 54%). The metric used is MSE (Mean Squared Error).

IMPLEMENTATION AND VALIDATION

The model was implemented in the client’s infrastructure. Thanks to the introduction of the solution, it was possible to minimize the forecast error to just 3%. This means that accurate estimates can already be made at the stage of contracting raw material supplies.

“This preliminary model research was conducted on a subset of the dataset, and the model that was decided to be the best was later on deployed in our client’s infrastructure and we performed the full training using the complete set of production data from historical production runs. The final model was deployed to production with the mean squared error below 3% for the real-world production runs.“

This solution was developed according to our build, operate, transfer model. “We build the solution using our knowledge and expertise in the first step. Then we helped with setting up the infrastructure and the processes to meet the operational requirements, and finally, the product was transferred to the client, who receives the full ownership of the solution. With this process, we are not only trying to create solutions for individual problems but rather to create a platform for the ongoing development of innovations in the environment of our clients.”

At Inero Software, we believe that software goes beyond just the technical; it’s also about people, business, and delivering on sustainable long-term objectives. By leveraging the BOT model, we establish a lasting innovation framework within our client’s operations, enabling them to set and achieve long-term business goals through the power of innovation.

Waldemar Korłub, Eng. PhD

CO-FOUNDER INERO SOFTWARE

waldemar.korlub@inero.pl

Artykuł Case study: Deploying an AI-based solution at Farm Frites Poland pochodzi z serwisu Inero Software - Software Consulting.

Optimization of Data Collection Process Thanks to AI Algorithms

In an era of progress and numerous achievements in natural language processing, we see increasing possibilities in the analysis and inference based on data collected in unstructured textual archives and documents. Therefore, streamlining business operations and implementing NLP (Natural Language Processing) and LLM (Large Language Models) tools become essential. The digitization of business processes moves many tasks into the virtual world, and controlling and analyzing a large volume of collected data becomes a significant challenge.

Save time

Of course, time is crucial. In the age of constant haste, laborious analytical tasks requiring focus, precision, and diligence become a burden for efficient and often dispersed teams. The modern business operates swiftly. Many industries, such as accounting, law firms, insurance, or transportation, place significant emphasis on the quality of documentation, which significantly impacts group efficiency.

Let’s take the transportation sector as an example. TSL companies handle dozens of freight shipments daily, each generating a large amount of documentation, including invoices, contracts, policies, delivery notes, and driver logs. When added to the internal administrative workflow, it’s easy to overlook an unreadable document (e.g., hastily scanned), which can disrupt the document circulation process at a later stage and require corrections, thus significantly extending the task list. This could affect cash flow. Therefore, optimizing the data collection process with the right quality becomes crucial.

Traditional methods are becoming less effective

Traditional software development methods are becoming less effective when dealing with large databases. They often rely solely on structurally processed data and predefined rules, which may not be suitable for working with unstructured text and the subtleties of natural writing. The classical approach to software development faces challenges when dealing with large knowledge bases.

Working on DocsQuality, we lower the barrier for teams to access NLP (Neuro-Linguistic Programming) and LLM (Large Language Model) tools, enabling them to easily retrieve data from unstructured texts and documents.

The role of DocsQuality software is to assess document attributes before they are imported into the accounting workflow. It evaluates real-time factors such as readability, clarity, and file quality. The software immediately highlights issues, for example, with email attachments, signaling that the system should not accept the document into the workflow at this stage.

NLP and LLM models

Combining and applying NLP and LLM models is an innovative method for assessing document quality. During software development, NLP can be used to extract text from image documents, utilizing Optical Character Recognition (OCR) techniques to transform image text into editable text, which can then be evaluated for quality. On the other hand, LLM models can read and understand text in PDF documents, allowing for assessment of readability, grammar, syntax, and spelling correctness, followed by content analysis, inference, and understanding.

The engineers at Inero Software are continuously developing the functionalities offered by DocsQuality. Creating new software in such a dynamic environment requires constant improvement and searching for optimal solutions. The potential of integrating NLP and LLM tools into this software will enable even more precise documentation analysis in the future.

DocsQuality software

If you are interested in DocsQuality software, we invite you to visit our website at https://docsquality.com/ and contact us via email at hi@docs-quality.com. We would be happy to answer all your questions and provide information about its functionalities and implementation. DocsQuality can be successfully integrated with an existing ERP system, expanding the offered functionalities to include effective monitoring of document quality, and allowing the identification of problematic files before they are introduced into the accounting workflow.

Artykuł Optimization of Data Collection Process Thanks to AI Algorithms pochodzi z serwisu Inero Software - Software Consulting.

INTRODUCTION

ChatGPT was introduced a few weeks ago and since then it has been one of the main topics in the IT industry. In this blog post, we’ll take a closer look at what GPT is and the potential applications of this powerful technology in the hands of software engineer. GPT-3 is the third and newest generation of GPT models and it is one of the most powerful language so far. It is trained with a big amount of text data from multiple sources which include websites and books. It can be still fine-tuned for a wide range of tasks, including text summarization, extracting data from documents and question answering in one of the many specific domains.

ChatGPT, on the other hand, is the most recent specialized version of the GPT-3, tailored to the needs of chatbot applications. Reinforcement Learning with Human Feedback (RLHF) was used to improve the model’s outputs by incorporating human feedback during training. By learning from human corrections and preferences, the model’s output can become more accurate. In many cases this model can be generally faster and more efficient than GPT-3 and that’s why it can be a better choice for use in real-time use-cases. However, in general it may be not as powerful as the source model which can be additionally fine-tuned. They both seems to be designed for different purposes.

There are also other GPT-3-based (older) models that are specifically designed to work with code rather than general natural language. OpenAI Codex is pre-trained on a large dataset of code, which allows it to ‘understand’ the structure and semantics of code. One of the most popular Codex-based tools is Github Copilot that uses this model to suggest code and entire functions in real-time even from IDE.

That’s some theory. But can we efficiently work with code, at least in some way, using the newest solution – ChatGPT instead of Codex-based ones?

PLAYING IN THE PLAYGROUND

#CASE 1

In the first step, we checked how the model deals with modelling domain classes and incorporating the Domain Driven Design (DDD) approach (at least in very basic version). In short, Domain-Driven Design (DDD) is methodology that aims to bridge the gap between business and software by aligning the structure of the code with the business domain it represents. DDD utilizes principles and patterns to create a clear mapping between the business and software, making it easier for developers to understand the code and for domain experts to understand the software.

Input: Give me an example of using Domain Driven Design. Let this be an example of a car booking system. There we should have reservations, users and cars. Indicate what could be Value Object, Entity, and Aggregate.
Output:

ChatGPT correctly generated classes for the domain objects we specified, assigned them some useful properties and methods, and correctly marked value objects, aggregate roots and entities. No errors, no code smells.

#CASE 2

Input: Write a C# method with a string parameter that returns a Base64 version of the input GUID.
Output:

All lines of code seem to be at least correct again. But it’s important to handle exceptions in any method that deals with input that can be malformed or otherwise invalid. In fact, there is a place where exception could be thrown. All we have to do is just ask for changes.

Input: What about handling exceptions?
Output:

#CASE 3

Input: Prepare a simple .NET API which returns current weather in a specified city.
Output:

GET method asynchronously calls an external API – OpenWeatherMap to retrieve temperature and description. It also does understand that we need to generate our own API key. In the next lines there is a mapping from JSON to Weather class. It does not use any mapping library nor does it manually, instead it makes some workaround using JsonSerializer. It seems like a fully acceptable solution.

SUMMARY

In many cases, picking the right model is a matter of preference. It seems like Codex/Copilot is more responsive, while ChatGPT is more proactive at work. Copilot can be a good choice for preparing short snippets or scanning all your code, and everyone else’s, and coming up with little adjustments on the fly. It learns style conventions and will adapt to suggestions. It really speeds up the amount of characters on the page and makes refactoring easier as well.

But ChatGPT is good to get broad architectural outlines and answer our questions. It’s easier to use this model for inspiration / exploratory work because we can specify what parts we don’t like and how we would like to change them. It’s more like an AI assistant where you can enter a piece of code and ask it to optimize or refactor it.

Both solutions work in different way but in many cases provide optimal answers if we ‘ask’ them in a proper way. Codex-based tools work more like a tactical advisor, making our tasks done faster and in a more effective way, while ChatGPT can possibly provide us improvements and alternative methods. From a practical point of view they both still are great choice for one-off utilities and functions.

What we have presented here is only a teaser, there is much more to explore. Technologies like these can help software engineers to be more productive by automating tasks that are typically time-consuming or repetitive, such as writing code, documentation and debugging, which allows programmers to focus on more complex and creative tasks.

Overall, GPT-like models can be a valuable tool for programmers when used in conjunction with other programming tools and best practices, but it’s not a complete replacement for a human software engineer. Sometimes they can be wrong and we have to keep that in mind.

In Inero Software we build digital products for digital logistics of tomorrow. We connect active aproach to analysis of business needs and combine with cutting edge technologies and AI/ML.

Artykuł ChatGPT – A developer’s point of view pochodzi z serwisu Inero Software - Software Consulting.

String beforeTextBlock = "SELECT some_id, COUNT(*)\n" + 
        "FROM (\n" + 
        "         select da.some_date dd, d.id some_id\n" + 
        "         from some_aud da\n" + 
        "     ) as subq\n" + 
        "GROUP BY some_id\n" + 
        "\t\tDouble \"Double \"quotes\"\" test\n";

String withTextBlock = """ 
        SELECT some_id, COUNT(*) 
        FROM ( 
                 select da.some_date dd, d.id some_id 
                 from some_aud da 
             ) as subq 
        GROUP BY some_id 
        \t\tDouble „Double „quotes”” test 
        """;

if(someObject instanceof String) { 
    String someString = (String) someObject; 
    //Operacje na zmiennej someString 
}

if(someObject instanceof String someString) { 
    //Operacje na zmiennej someString 
}

public final class NoRecordClass { 
    private final String title; 
    private final String author; 

    public NoRecordClass(String title, String author, String isbn) { 
        this.title = title; 
        this.author = author; 
    } 

    public String getTitle() { 
        return title; 
    } 

    public String getAuthor() { 
        return author; 
    } 

    @Override 
    public boolean equals(Object o) { 
        if (this == o) return true; 
        if (o == null || getClass() != o.getClass()) return false; 
        NoRecordClass book = (NoRecordClass) o; 
        return Objects.equals(title, book.title) 
                && Objects.equals(author, book.author); 
    } 

    @Override 
    public int hashCode() { 
        return Objects.hash(title, author); 
    } 
}

public record RecordExample(String title, String author) { 
}

public sealed interface SealedInterface 
        permits ImplementationNo1, 
                ImplementationNo2, 
                ImplementationNo3 { 
    int getNumber(); 
    String getText(); 
    List<String> getStrings(); 
}

Artykuł Java 17: New features overview pochodzi z serwisu Inero Software - Software Consulting.