Consumers aren’t waiting for healthcare to evolve—they’re already redefining what access means. They expect care to be affordable and available, but that’s only the beginning. Increasingly, they also demand experiences that are convenient, personalized, and digitally seamless. When those expectations aren’t met, they don’t hesitate to look elsewhere.

Understanding this shift requires more than demographic segmentation or digital analytics. It calls for a behavioral lens. Maslow’s Hierarchy of Needs and the Transtheoretical Model (TTM) offer complementary frameworks that, when applied together with journey sciences, reveal a spectrum of motivations driving healthcare decisions today. 

• Maslow helps us understand the “what”—the needs consumers are trying to meet, from cost and access to comfort, trust, and self-agency.
• TTM explains the “how”—the stages people move through as they prepare to engage with care.

But in today’s healthcare environment, these needs and behaviors don’t unfold in a predictable sequence. Instead, consumers express a unique blend of foundational requirements and lifestyle-driven expectations, shaped by digital-native habits and experiences in other service industries. 

This convergence of digital and human needs reframes how healthcare organizations must think about access to care.

The following five themes illustrate how a digital strategy informed by Maslow’s hierarchy, the Transtheoretical Model, and consumer insights can help healthcare leaders reduce friction, deepen engagement, and deliver measurable value across the care journey. 

Maslow’s Hierarchy Reimagined for Modern Healthcare 

Consumers still care about the basics—cost, insurance acceptance, and appointment availability. But they also expect experiences that reflect their identity, preferences, and time constraints. These expectations map to Maslow’s Hierarchy of Needs, but not in a linear way. 

• Foundational Needs: Insurance acceptance, out-of-pocket costs, appointment availability 
• Psychological Needs: Trust in providers, comfort with care teams, digital convenience 
• Self-Fulfillment Needs: Personalized experiences, proactive health management, seamless coordination 

Strategic Insight: Consumers are blending survival needs with lifestyle demands. Digital transformation must address both simultaneously. 

Behavioral Change is a Journey—Use the Transtheoretical Model to Guide It 

TTM offers a behavioral framework that aligns with how consumers engage with healthcare: 

Why it matters: Aligning digital tools with behavioral stages helps move consumers from passive to proactive engagement, improving both outcomes and retention. 

Caregivers Are the Hidden Power Users of Your Network 

One in three respondents in our 2025 Access to Care healthcare research study identified as caregivers. These important participants aren’t just supporting others. They’re often making the decisions about care teams, insurance plans, appointments, and more.

That means one person’s health care decisions can influence the outcomes and satisfaction of an entire household and beyond. Ignoring this persona means missing out on a major driver of patient loyalty and continuity. 

Design for Caregivers by Enabling: 

• Multi-profile scheduling 
• Shared access to care plans and records 
• Streamlined communication across care teams 

Friction is Expensive and Avoidable 

When scheduling is hard, people delay care or abandon it altogether. That’s not just a patient experience issue. It’s a revenue and health outcomes issue. Our 2025 Access to Care healthcare research study revealed that:

• 33.8% of caregivers reported difficulty scheduling care 

• 23.3% of all respondents who reported appointment-scheduling friction said this led to worsened health 

• More than 50% of those who experienced friction switched providers 

Actionable Moves: 

• Prioritize multi-modal engagement (digital, phone, in-person) 
• Integrate financial transparency into scheduling workflows 
• Design for caregivers—the hidden influencers of health decisions 

Healthcare is Competing With Commerce—And Losing Ground 

Digital-first care platforms are gaining traction because they’re easy, fast, and transparent. Consumers don’t compare healthcare to other hospitals or member portals—they compare it to Amazon, Uber, and their favorite apps. 

Strategic Response: 

• Treat Find-a-Provider as your digital front door 

• Use AI and predictive analytics to match patients with the right care, then make the path to schedule and receive care as seamless as possible

• Partner with urgent care and digital-first platforms to extend reach 

Final Word: Build for Behavior, Not Just Compliance 

Access isn’t a single point—it’s a cascade of decisions, behaviors, and expectations. By aligning digital strategy with a deep understanding of consumer behavior—whether through the lens of Maslow’s Hierarchy of Needs, the Transtheoretical Model (TTM), or journey sciences—healthcare leaders can design systems that are not only more human but more effective. 

Access is the new front door. Make sure it opens easily. 

Ready to Elevate Access to Care?

If you’re exploring how to modernize your digital front door, consider starting with a strategic assessment. Align your goals, audit your content, and evaluate your tech stack. The path to better outcomes starts with a smarter, simpler way to help patients find care.

We combine strategy, industry best practices, and technology expertise to deliver award-winning results for leading healthcare organizations.

• Business Transformation: Activate strategy for transformative outcomes and health experiences.
• Modernization: Maximize technology to drive health innovation, efficiency, and interoperability.
• Data + Analytics: Power enterprise agility and accelerate healthcare insights.
• Consumer Experience: Connect, ease, and elevate impactful health journeys.

Our approach to designing and implementing AI and machine learning (ML) solutions promotes secure and responsible adoption and ensures demonstrated and sustainable business value.

Discover why we have been trusted by the 10 largest health systems and the 10 largest health insurers in the U.S.  Explore our healthcare expertise and contact us to learn more.

The recent Tricentis India Partner Event was more than just a gathering of quality engineering professionals — it was a showcase of how intelligent testing, fueled by AI and automation, is redefining the way we think about software quality, speed, and resilience. We at Perficient take great pride in being part of this esteemed event.

As someone passionate about testing transformation, this event offered deep insights and future-forward perspectives that I believe every QA and engineering leader should be thinking about.

Embracing AI Across the Testing Lifecycle

The most exciting theme across sessions and demos was how AI is no longer an emerging trend in testing — it’s the new foundation.

Across the Tricentis product suite, AI is:

• Accelerating test creation and self-healing with tools like Tosca and Testim
• Enhancing test coverage analysis and enabling risk-based test optimization through Tricentis Test Intelligence (TTI)
• Powering smart impact analysis for SAP via LiveCompare
• Driving real-time performance diagnostics and dynamic test design in NeoLoad

The value? Faster test cycles, reduced maintenance, smarter prioritization, and improved release quality.

The Power of a Unified, AI-Enabled Suite

Each product in the Tricentis ecosystem serves a unique purpose, but together they create a unified, intelligent platform for end-to-end continuous testing:

• Tosca: Model-based, AI-powered automation for robust regression coverage
• Testim: Agile-friendly, low-code UI test automation
• NeoLoad: Scalable performance testing with real-time feedback
• qTest: Centralized test management with rich traceability
• LiveCompare: AI-based change impact analysis for SAP
• TTI: Machine learning that surfaces high-risk test cases dynamically

This AI-first approach is not only improving the effectiveness of testing, but also enabling teams to shift-left, test early, and release confidently.

Fireside Chat: Perspectives That Resonate

One of my favorite moments from the event was the Fireside Chat with testing experts. The conversation went beyond tools and tackled real challenges:

• How do we move from automation to true intelligence in testing?
• What’s the future role of QA in a world where AI generates, executes, and evaluates tests?
• How can we upskill our teams and bring them along on this transformation journey?

The insights shared by the panel were practical, strategic, and inspiring — a clear call to action for all of us to embrace change and lead innovation in our organizations.

From QA to Quality Engineering Leadership

This event validated a key belief I hold: Quality is no longer a checkpoint — it’s a capability.

As leaders, our role is shifting from testers to quality enablers, embedding intelligence, speed, and resilience across the software development lifecycle.

My Top 5 Takeaways:

1. AI is now essential — not optional — in modern testing
2. Comprehensive End-to-End Testing with Tricentis Tools
3. Unified platforms drive better visibility, traceability, and scalability
4. Performance and functional testing must move together, continuously
5. Risk-based testing using ML is the future of test prioritization

I’m incredibly thankful to the Tricentis team for curating such a powerful learning experience and for driving innovation across the testing landscape.

As we step into this AI-driven era of quality, I’m excited to apply these learnings and continue championing AI-led test transformation in every organization I touch.

In today’s fast-paced digital landscape, businesses often find themselves in a peculiar situation: they’re brimming with valuable data, specialized tools, and incredibly talented teams, yet connecting these pieces efficiently can feel like navigating a complex maze. Individual departments might develop ingenious solutions, but these often remain isolated, creating fragmented processes and slowing down the adoption of true innovation.

This isn’t just about finding information; it’s about action. Imagine trying to streamline a critical business process, only to realize the necessary data is scattered across multiple systems, or the expert who knows how to unlock its full potential are not available. This fragmentation isn’t just inefficient; it’s a productivity bottleneck that prevents organizations from truly leveraging the power of AI.

The Power of Protocol: Connecting AI to Your Business Needs

At Perficient, we’re building a future where AI isn’t just a collection of disparate tools, but a unified, intelligent ecosystem that seamlessly integrates with your existing operations. We’re doing this by embracing a powerful concept: standardized protocols for AI applications, particularly the MCP (Model Context Protocol).

Think of it like the USB-C port for AI. Just as USB-C provides a universal way to connect devices, we’re advocating for a standardized method that allows AI models to effortlessly “plug into” diverse data sources, specialized tools, and even other advanced AI capabilities. This eliminates the traditional hurdles of custom integrations and siloed solutions, opening up a world of possibilities.

This approach means that highly specialized AI solutions can be developed, managed, and then easily integrated into a broader intelligent framework. Imagine a sales enablement AI that can instantly tap into your extensive product documentation, personalized customer histories, and market insights to generate hyper-relevant proposals. Or consider a project management AI that guides your teams through best practices, automatically surfaces relevant resources, and even identifies the ideal subject matter expert for a tricky client challenge – all while adhering to your company’s unique workflows.

Intelligent Automation: From Data to Dynamic Action

What truly sets this approach apart is the capability for these integrated AI solutions to not just provide information, but to orchestrate and execute intelligent automation. This means your AI can go beyond answering questions; it can trigger sophisticated, multi-step processes. Need to perform deep market research that requires gathering data from various internal reports, external databases, and even analyzing competitive landscapes? A well-integrated AI can orchestrate that entire process, delivering a synthesized analysis or even taking proactive steps, like scheduling follow-up meetings based on its findings.

This is where AI transitions from a helpful assistant to a true force multiplier for your business. It allows you to automate complex workflows, streamline decision-making, and unlock new levels of efficiency.

Driving Unified Innovation for Your Business

At Perficient, our internal Generative AI system, Scarlett, is a testament to this vision. Scarlett acts as a unified front-end, demonstrating how a standardized approach to AI can centralize efforts, streamline access to specialized intelligence, and accelerate solution adoption across diverse teams. This internal capability reflects the same principles we apply to help our clients achieve:

• Atomization of Effort: Break down large, complex problems into manageable, AI-powered components that can be rapidly developed and deployed.
• Centralized Access & Governance: Provide a single, intuitive interface for all your AI-driven capabilities, ensuring consistency, security, and scalability.
• Accelerated Progress & Adoption: When AI is easy to access and seamlessly integrated, your teams can adopt new solutions faster, democratize specialized knowledge, and drive innovation across the entire organization.

Ultimately, this unified approach to AI is about empowering your business to operate smarter, faster, and more cohesively. It’s about transforming how you deliver value to your customers and achieve your strategic objectives in an increasingly AI-driven world.

In Adobe’s 2025 AI and Digital Trends report, one message rings loud and clear: the convergence of marketing and IT is essential to digital success. As AI becomes increasingly embedded in customer experience strategies, marketing and IT leaders must collaborate closely to unlock its full potential.

The Rise of Agentic AI

One of the most transformative ideas in the report is the rise of agentic AI, autonomous systems that collaborate across platforms to deliver hyper-personalized, real-time experiences. For marketing and IT leaders, this represents a major shift. These aren’t just tools, but strategic partners capable of transforming how content is created, optimized, and delivered at scale.

This shift is already being realized in the field, as industry leaders begin to harness the power of Agentic AI to streamline operations and enhance customer outcomes. For example, Perficient’s Adobe services delivery team is leveraging the technology to make AEM as a Cloud Service migrations faster.

“The emergence of Agentic AI is revolutionizing our service delivery, delivering significant time and effort savings for our customers. Take the move to AEM Cloud, for instance. We’re leveraging agents to handle tasks like code remediation and complex mapping for advanced content migrations into AEM,” says Robert Sumner, principal in Perficient’s Adobe practice.

As organizations explore these capabilities, the collaboration between marketing and IT becomes even more critical. IT leaders must ensure the infrastructure is in place to support real-time data flow and AI orchestration, while marketers must rethink workflows to fully leverage AI’s creative and analytical potential.

Nearly two-thirds (65%) of senior executives identify leveraging AI and predictive analytics as primary contributors to growth in 2025. (Adobe 2025 Digital Trends report)

Seamless, Personalized Experiences

The report also highlights a growing emphasis on predictive analytics. Businesses are moving beyond reactive strategies to proactively anticipate customer needs. This shift is enabling more meaningful, real-time interactions across the customer journey.

For marketing leaders, this means moving beyond historical performance metrics to real-time, forward-looking insights. For IT, it means ensuring the data infrastructure is robust, integrated, and accessible across teams. However, many organizations still struggle with siloed systems and fragmented data, which hinder their ability to deliver seamless experiences.

Ross Monaghan, principal in Perficient’s Adobe practice, underscores this point by highlighting how leading organizations are turning data into action through AI-powered strategies.

“We don’t have a shortage of data. The challenge lies in consuming it, unifying it, and activating it in real time to deliver personalized, one-to-one experiences that meet the demands of consumers. Organizations that are winning are already leveraging predictive bidding, dynamic budget allocation, and channel mix modelling to optimize media buying. They’re also developing AI-driven audience clusters based on behavior, intent, or psychographics to improve targeting precision. By training models on past customer behavior, they can predict which leads are most likely to convert. The possibilities are endless if you embrace the power of what AI can bring to the table. AI isn’t here to replace us, it’s here to eliminate the thousands of hours spent on manual tasks, chasing insights that may or may not exist in fragmented data,” says Monaghan.

Efficient, accurate, and personalized experiences all start with secure and reliable data. Learn More

Breaking Down Silos to Boost Adoption

The customer journey is increasingly owned by a mix of marketers, technologists, and CX specialists. And while this diversity brings valuable perspectives, it can also lead to friction and inefficiencies. Marketing needs IT to deliver scalable, secure, and flexible platforms. IT needs marketing to define the customer vision and drive innovation. The report suggests that aligning these teams around shared goals and metrics is essential for success and the ability to deliver seamless, personalized experiences.

Monaghan says, “Organizations must continue to view everything through the lens of the customer. That means breaking down internal silos, politics, and bureaucracy. Customers don’t care who owns the data or whether it sits with IT or marketing. What matters is that we come together to identify key audiences, mapping core personas and journeys, and developing dynamic use cases that guide each user through a personalized experience. We then can analyze the effectiveness of content, offers, and sentiment to drive customer lifetime value at scale.”

Ensuring Responsible AI Deployment

The report also addresses the ethical dimensions of AI. Issues like data privacy, algorithmic bias, and transparency are top of mind for both marketing and IT leaders. Building trust with customers requires more than compliance. It demands intentional governance. IT leaders must implement frameworks for responsible AI use, while marketers must ensure that personalization efforts respect user boundaries and values.

The Time to Act is Now

Adobe’s 2025 report is both a roadmap and a call to action for marketing and IT leaders. The future belongs to organizations that can harness AI not just as a tool, but as a strategic enabler, bridging creativity and technology to deliver exceptional customer experiences.

Abstract

In recent years, language models and AI have reshaped how we interact with data. Yet, a significant portion of business knowledge still resides in relational databases (highly structured but not exactly user-friendly for those unfamiliar with SQL). So what if you could query that data using natural language, as if you were speaking to a smart assistant?

In this post, we’ll walk through a practical proof of concept (POC) using the well-known Northwind database as our data source. We’ll apply Retrieval-Augmented Generation (RAG) techniques to convert structured data into meaningful, searchable knowledge. By combining tools like LangChain, OpenAI Embeddings, and ChromaDB, we’ll build a system that can answer real business questions about customers, orders, and sales (all without writing a single SQL query).

This hands-on example will demonstrate how to turn raw database records into descriptive text, generate semantic embeddings, and store them in a vector database optimized for intelligent retrieval. Finally, we’ll connect a conversational AI model to deliver precise, context-aware answers in plain language.

Our goal isn’t just to show a technical integration (it’s much more than that). We aim to explore a new way of accessing business data that’s intuitive, scalable, and aligned with the future of intelligent interfaces. If you’ve ever wondered how to bring your data to life through conversational AI, this is the roadmap you’ve been looking for.

Introduction

Relational databases have been the backbone of enterprise systems for decades, offering structured and reliable storage for vast amounts of business information. However, accessing that data still relies heavily on technical users who are comfortable writing SQL queries (which limits its utility for many other roles within an organization). This post aims to demonstrate how we can transform structured data into accessible knowledge through AI-powered conversational interfaces.

To do this, we’ll build a practical proof of concept using the classic Northwind database (a well-known dataset that includes customers, orders, products, and more). Instead of querying the data directly with SQL, we’ll generate readable and semantically rich descriptions that can be interpreted by a language model. These textual fragments will be converted into embeddings using OpenAI, stored in a vector database powered by ChromaDB, and made retrievable through LangChain, all using Python as the orchestration layer.

Why apply embeddings to tabular data? Because it allows us to move beyond the rigid structure of SELECT statements and JOINs (toward a system where users can ask questions like “Which customer bought the most in 1997?” and receive clear, context-aware answers in natural language). This approach does not replace traditional querying techniques (instead, it complements them), making data access more inclusive and aligned with modern AI-driven experiences.

Ultimately, this opens the door to a new way of working with data (one where conversation replaces complexity and insight becomes truly accessible).

What Are Embeddings?

One of the fundamental challenges in working with language models or textual data is representation. Computers operate on numbers, but words have no inherent numerical value. To bridge this gap, we need a way to transform text into a format that machines can understand while still preserving its semantic meaning. This is precisely where embeddings come into play.

Embeddings are dense vector representations of words, sentences, or even entire documents. Each piece of text is mapped to a real-valued vector—often in a space with hundreds or thousands of dimensions—where semantic relationships can be modeled geometrically. Unlike older methods like one-hot encoding, embeddings allow us to capture similarity: words such as “king” and “queen” appear close together, while unrelated terms like “king” and “lettuce” remain far apart.

The real power of embeddings lies in their ability to reflect meaning. This enables models to reason not just about the surface of the text, but about what it implies—unlocking applications in translation, sentiment analysis, document classification, recommendation systems, semantic search, and, crucially, retrieval-augmented conversational agents.

In the context of this blog, we use embeddings to convert structured database records into descriptive, semantically rich text fragments. These fragments are embedded using a model like OpenAI’s and stored in a vector database. When a user asks a question, it too is embedded, and the system retrieves the most relevant fragments to generate a natural-language answer. This technique is part of what’s known as Retrieval-Augmented Generation (RAG).

Embeddings are commonly produced by pre-trained models from providers like OpenAI, Hugging Face, or Cohere. In our case, we rely on OpenAIEmbeddings, which leverage large-scale transformer models trained on diverse, multilingual datasets optimized for semantic understanding.

One of the greatest advantages of embeddings is their ability to generalize. For instance, a user might ask “Who was the top customer in 1997?” and the system can infer related notions like “highest purchase volume” or “most frequent buyer” without needing exact word matches. This goes far beyond traditional keyword-based search.

Modern embeddings are also contextual. In models like BERT, ELMo, or GPT, the vector for a word depends on its surrounding text. The word “bank” in “sat on the bank” and “deposited money in the bank” will generate entirely different embeddings. This dynamic understanding of context is one reason why these models perform so well in complex language tasks.

In our use case, we apply embeddings to fragments derived from SQL queries, effectively transforming structured information into semantically searchable knowledge. This enables a more natural interaction with data, where users don’t need to understand database schemas or SQL syntax to retrieve meaningful insights.

The pipeline involves embedding each text chunk, storing the resulting vectors in a vector store like ChromaDB, and embedding the user’s query to perform a similarity search. The most relevant matches are passed to a language model, which uses them as context to generate an intelligent, context-aware response.

This method not only streamlines access to information but also enhances accuracy by leveraging the semantic proximity between questions and data fragments.

Let’s understand, what is a chunk?

In the context of language models and semantic search, chunks refer to small, meaningful segments of text that have been split from a larger document. Rather than processing an entire file or paragraph at once, the system breaks down the content into manageable pieces (usually a few hundred characters long with some overlap between them). This technique allows the model to better understand and retrieve relevant information during a query.

Chunking is essential when working with long documents or structured data transformed into natural language. It ensures that each piece maintains enough context to be useful while staying within the token limits of the language model. For example, an entire order history from a database might be divided into chunks that describe individual transactions, making it easier for the system to locate and reason over specific details.

This process not only improves the efficiency of embedding generation and similarity search but also enhances the relevance of responses provided by the conversational agent.

LangChain and ChromaDB: Connecting Language Models to Meaningful Data

To build a system where users can ask questions in natural language and receive intelligent, relevant answers, we need more than just a powerful language model (we need a framework that can manage context, memory, and retrieval). That’s where LangChain comes in.

LangChain is an open-source framework designed to help developers integrate large language models (LLMs) with external data sources and workflows. Rather than treating the model as a black box, LangChain provides structured components (like prompt templates, memory modules, agents, and chains) that make it easier to build dynamic, stateful, and context-aware applications. One of its most popular use cases is Retrieval-Augmented Generation (RAG) (where the model uses external knowledge retrieved from a document store to improve its responses).

To make this retrieval process efficient and accurate, LangChain works seamlessly with ChromaDB.

ChromaDB is a lightweight, high-performance vector database optimized for storing and querying embeddings. It enables fast similarity searches (allowing the system to retrieve the most semantically relevant pieces of information based on a user’s query). This makes Chroma ideal for use in search engines, recommendation systems, and conversational agents.

In a LangChain workflow, ChromaDB serves as the brain’s long-term memory. It stores the embedded representations of documents or data fragments, and returns the most relevant ones when queried. These fragments are then injected into the language model as context (resulting in more accurate and grounded responses).

Together, LangChain and ChromaDB bridge the gap between raw data and intelligent conversation.

Proof of Concept: From SQL Rows to Smart Conversations

In this section, we’ll walk through the steps of building a fully functional proof of concept. Our goal: enable users to ask questions in plain language (such as “Which customers placed the most orders in 1997?”) and get accurate answers generated using data from a relational database.

We’ll use the classic Northwind database, which contains tables for customers, orders, products, and more. Instead of querying it directly with SQL, we’ll extract meaningful data, turn it into descriptive text fragments, generate semantic embeddings, and store them in ChromaDB. Then, we’ll use LangChain to retrieve relevant chunks and feed them to OpenAI’s language model (turning structured data into natural conversation).

For this Proof of Concept you must follow the following steps:

Step 0: Environment setup

Before diving into building the intelligent assistant, it’s essential to prepare a clean and isolated development environment. This ensures that all dependencies are properly aligned, and avoids conflicts with other global Python packages or projects. Here’s how to set up everything from scratch.

Create Embedding Depployment

Before we can generate embeddings from our text data, we need to create a deployment for an embedding model within our Azure OpenAI resource. This deployment acts as the gateway through which we send text and receive vector representations in return.

Figure 1: Azure OpenAI – Embedding and Chat Model Deployments.

To begin, navigate to your Azure OpenAI resource in the Azure Portal. Select the Deployments tab, then click + Create to initiate a new deployment. Choose the model text-embedding-3-small from the dropdown list (this is one of the most efficient and semantically rich models currently available). Assign a unique name to your deployment—for example, text-embedding-3-small—and ensure you take note of this name, as it will be required later in your code.

Figure 2: Selecting the Text Embedding Model (text-embedding-3-small) in Azure OpenAI.

Once deployed, Azure will expose a dedicated endpoint along with your API key. These credentials will allow your application to communicate securely with the deployed model. Be sure to also confirm the API version associated with the model (such as 2024-02-01) and verify that this matches the version specified in your code or environment variables.

By completing this step, you set up the foundation for semantic understanding in your application. The embedding model will convert text into high-dimensional vectors that preserve the meaning and context of the input, enabling powerful similarity search and retrieval capabilities later on in your pipeline.

LLM Model Deployment

Don’t forget to configure the LLM model as well (such as gpt-4.1-mini), since it will be responsible for generating responses during the interaction phase of the implementation.

Figure 3: Deploying the LLM Base Model in Azure OpenAI (gpt-4.1-mini).

Figure 4: Selecting a Chat completion Model from Azure OpenAI Catalog.

To connect your application with the deployed LLM, you will need the endpoint URL and the API key shown in the deployment details. This information is essential for authenticating your requests and sending prompts to the model. In this case, we are using the gpt-4.1-mini deployment with the Azure OpenAI SDK and API key authentication. Once retrieved, these credentials allow your code to securely interact with the model and generate context-aware responses as part of the proof of concept.

Figure 5: Accessing Endpoint and API Key for gpt-4.1-mini Deployment.

The key information we need from this screenshot to correctly configure our code in the Proof of Concept is the following:

1. Endpoint URL (Target URI)
   (Located under the “Endpoint” section)
   This is the base URL you will use to send requests to the deployed model. It’s required when initializing the client in your code.

2. API Key
   (Hidden under the “Key” field)
   This is your secret authentication token. You must pass it securely in your code to authorize requests to the Azure OpenAI service.

3. Deployment Name
   (Shown as “gpt‑4.1‑mini” in the “Deployment info” section)
   You will need this name when specifying which model deployment your client should interact with (e.g., when using LangChain or the OpenAI SDK).

4. Provisioning Status
   (Shows “Succeeded”)
   Confirms that the deployment is ready to use. If this status is anything other than “Succeeded,” the model is not yet available.

5. Model Version and Creation Timestamp
   (Optional, for auditing or version control)
   Useful for documentation, debugging, or future migration planning.

Create a requirements.txt file

Start by listing all the libraries your project will depend on. Save the following content as requirements.txt in your project root:

pyodbc
langchain==0.3.25
openai==1.82.0
chromadb==1.0.10
tiktoken
pydantic
langchain-core
langchain-community
langchain-text-splitters
langchain-openai==0.1.8

This file defines the exact versions needed for everything—from LangChain and ChromaDB to the Azure OpenAI integration.

Create a virtual environment

To avoid interfering with other Python installations on your machine, use a virtual environment. Run the following command in your terminal:

python -m venv venv

This creates a dedicated folder called venv that holds a self-contained Python environment just for this project.

Activate the virtual environment

Next, activate the environment:

venv\Scripts\activate

Once activated, your terminal prompt should change to reflect the active environment.

Install dependencies

Now install all required libraries in one go by running:

pip install -r requirements.txt

This will install all the packages listed in your requirements file, ensuring your environment is ready to connect to the Northwind database and work with LangChain and Azure OpenAI. With everything in place, you’re ready to move on to building the assistant—from querying structured data to transforming it into natural, intelligent responses.

Step 1: Azure OpenAI Configuration

Before diving into code, we need to configure the environment so that our application can access Azure OpenAI services securely and correctly. This involves setting three essential environment variables:

• AZURE_OPENAI_API_KEY (your Azure OpenAI API key)

• AZURE_OPENAI_ENDPOINT (the full endpoint URL of your Azure OpenAI resource)

• AZURE_OPENAI_API_VERSION (the specific API version compatible with your deployed models)

These variables are defined directly in Python using the os.environ method:

# --- 1. Environment setup ---
os.environ["AZURE_OPENAI_API_KEY"] = "<ApiKey>"
os.environ["AZURE_OPENAI_ENDPOINT"] = "<Endpoint>"
os.environ["AZURE_OPENAI_API_VERSION"] = "<AzureOpenIAVersion>"

By setting these values, LangChain will know how to connect to your Azure deployment and access the correct models for embeddings and chat completion.

It’s important to ensure that the deployment names used in your code match exactly the ones configured in your Azure portal. With this step complete, you’re now ready to start connecting to your database and transforming structured data into natural language knowledge.

Step 2: Connecting to the database

With the environment ready, the next step is to connect to the Northwind database and retrieve meaningful records. Northwind is a well-known sample dataset that contains information about customers, employees, orders, products, and their relationships. It offers a rich source of structured data for demonstrating how to turn database rows into conversational context.

To begin, we establish a connection with a local SQL Server instance using pyodbc (a Python driver for ODBC-based databases). Once connected, we execute a SQL query that joins several related tables (Orders, Customers, Employees, Order Details, and Products). This query returns detailed records for each order (including the customer who placed it, the salesperson involved, the date, and the specific products purchased with their quantities, prices, and discounts).

By retrieving all of this information in a single query, we ensure that each order contains enough context to be transformed later into meaningful text that a language model can understand.

# --- 2. Database connection ---
conn = pyodbc.connect(
    "DRIVER={ODBC Driver 17 for SQL Server};SERVER=localhost;DATABASE=Northwind;Trusted_Connection=yes;"
)
cursor = conn.cursor()
cursor.execute("""
    SELECT 
        o.OrderID,
        c.CompanyName AS Customer,
        e.FirstName + ' ' + e.LastName AS Salesperson,
        o.OrderDate,
        p.ProductName,
        od.Quantity,
        od.UnitPrice,
        od.Discount
    FROM Orders o
    JOIN Customers c ON o.CustomerID = c.CustomerID
    JOIN Employees e ON o.EmployeeID = e.EmployeeID
    JOIN [Order Details] od ON o.OrderID = od.OrderID
    JOIN Products p ON od.ProductID = p.ProductID
""")
records = cursor.fetchall()

Step 3: Transforming records into text

Relational databases are optimized for storage and querying, not for natural language understanding. To bridge that gap, we need to convert structured rows into readable, descriptive sentences that capture the meaning behind the data.

In this step, we take the SQL query results and group them by order. Each order includes metadata (such as customer name, date, and salesperson) along with a list of purchased products. We format this information into short narratives that resemble human-written descriptions.

For example, an entry might read:
“Order 10250 was placed by ‘Ernst Handel’ on 1996-07-08. Salesperson: Nancy Davolio. Items included: 10 x Camembert Pierrot at $34.00 each with 0% discount.”

By doing this, we make the data semantically rich and accessible to the language model. Instead of dealing with abstract IDs and numeric values, the model now sees contextually meaningful information about who bought what, when, and under what conditions. These text fragments are the foundation for generating accurate embeddings and useful answers later on.

Then, the next part of the code in charge of performing this task, is as follows

# --- 3. Transform records into text ---
from collections import defaultdict

orders_data = defaultdict(list)
for row in records:
    key = (row.OrderID, row.Customer, row.Salesperson, row.OrderDate)
    orders_data[key].append((row.ProductName, row.Quantity, row.UnitPrice, row.Discount))

documents = []
for (order_id, customer, seller, date), items in orders_data.items():
    lines = [f"Order {order_id} was placed by '{customer}' on {date:%Y-%m-%d}. Salesperson: {seller}."]
    lines.append("Items included:")
    for product, qty, price, discount in items:
        lines.append(f" - {qty} x {product} at ${price:.2f} each with {discount*100:.0f}% discount.")
    documents.append(" ".join(lines))

Relational databases are optimized for storage and querying, not for natural language understanding. To bridge that gap, we need to convert structured rows into readable, descriptive sentences that capture the meaning behind the data.

In this step, we take the SQL query results and group them by order. Each order includes metadata (such as customer name, date, and salesperson) along with a list of purchased products. We format this information into short narratives that resemble human-written descriptions.

For example, an entry might read:
“Order 10250 was placed by ‘Ernst Handel’ on 1996-07-08. Salesperson: Nancy Davolio. Items included: 10 x Camembert Pierrot at $34.00 each with 0% discount.”

By doing this, we make the data semantically rich and accessible to the language model. Instead of dealing with abstract IDs and numeric values, the model now sees contextually meaningful information about who bought what, when, and under what conditions. These text fragments are the foundation for generating accurate embeddings and useful answers later on.

Step 4: Splitting text into chunks

Once we have our text-based descriptions, the next challenge is to prepare them for embedding. Language models (and vector databases) perform best when working with manageable segments of text rather than long, unstructured paragraphs.

To achieve this, we break each document into smaller chunks using a character-based splitter. In this case, we set a chunk size of 300 characters with an overlap of 50 characters. The overlap ensures that important information near the edges of a chunk isn’t lost when transitioning between segments.

For example, if an order includes many products or a particularly detailed description, it may span multiple chunks. These overlapping fragments preserve continuity and improve the accuracy of downstream retrieval.

# --- 4. Split texts into chunks ---
splitter = CharacterTextSplitter(chunk_size=300, chunk_overlap=50)
docs = splitter.create_documents(documents)

This process not only improves the quality of the embeddings but also enhances retrieval performance later on, when a user asks a question and the system needs to locate the most relevant context quickly.

By preparing clean, consistent input in this way, we’re setting the stage for a robust and semantically aware assistant that understands each order at a granular level.

Step 5: Creating embeddings with Azure OpenAI

With our text chunks ready, the next step is to convert them into numerical representations that capture their semantic meaning. These representations, known as embeddings, allow the system to measure how similar one piece of text is to another—not by exact words, but by meaning.

To generate these embeddings, we use the text-embedding-3-small model deployed on Azure OpenAI. This model transforms each chunk into a high-dimensional vector, where semantically similar chunks are positioned close together in vector space.

# --- 5. Create embeddings with Azure OpenAI ---
embeddings = AzureOpenAIEmbeddings(
    deployment="text-embedding-3-small",  # Deployment correcto para embeddings
    model="text-embedding-3-small",
    api_version="2024-02-01"
)

For instance, two orders that include similar products or are placed by the same customer will produce embeddings that are close in distance. This similarity is what allows the assistant to later retrieve relevant information based on a natural language query, even if the wording is different.

Using Azure OpenAI for embeddings offers both scalability and enterprise-grade integration. It also ensures compatibility with the rest of our LangChain pipeline, as the embeddings can be seamlessly stored and queried within a vector database like Chroma.

This step essentially transforms our structured business data into a format that the language model can reason over—making it a critical part of the entire retrieval-augmented workflow.

Step 6: Storing embeddings in Chroma

Once the embeddings are generated, they need to be stored in a way that allows for fast and accurate retrieval. This is where Chroma comes in—a lightweight, high-performance vector database built specifically for handling semantic search.

Each text chunk, along with its corresponding embedding, is stored in Chroma using a local persistence directory. By doing so, we’re creating a searchable memory that allows the system to quickly find the most relevant fragments when a question is asked.

# --- 6. Store the embeddings in Chroma ---
db = Chroma.from_documents(docs, embeddings, persist_directory="./northwind_db")

Chroma supports similarity search out of the box. When a user submits a query, the system converts that query into its own embedding and searches the database for nearby vectors (in other words, the most semantically related pieces of content).

This design mimics how our own memory works—we don’t recall entire databases, just the most relevant bits based on context and meaning. Storing the embeddings in Chroma gives our assistant the same ability.

By the end of this step, we’ve effectively turned structured business data into a knowledge base that can be queried using natural language, enabling more intelligent and human-like interactions.

Step 7: Configuring the question-answering engine with AzureChatOpenAI

At this stage, we have a searchable knowledge base ready to go. Now it’s time to build the brain of the assistant—the component that takes a user’s question, retrieves the relevant context, and generates a natural, intelligent response.

We use AzureChatOpenAI, a LangChain-compatible wrapper for Azure-hosted GPT models. In this example, we configure it to use the gpt-4.1-mini deployment. This model serves as the core reasoning engine, capable of understanding user queries and formulating answers based on the data retrieved from Chroma.

LangChain’s RetrievalQA chain orchestrates the interaction. When a question is submitted, the process works as follows:

1. The system converts the query into an embedding.

2. Chroma searches for the most relevant chunks.

3. The retrieved chunks are passed as context to the GPT model.

4. The model generates a concise and informative response.

# --- 7. Configure RetrievalQA with AzureChatOpenAI ---
retriever = db.as_retriever()
llm = AzureChatOpenAI(
    deployment_name="gpt-4.1-mini",  # Deployment LLM
    model="gpt-4",                   # Model LLM
    api_version="2024-02-01",
    temperature=0
)
qa = RetrievalQA.from_chain_type(llm=llm, retriever=retriever)

This architecture is what makes Retrieval-Augmented Generation (RAG) so effective. Rather than relying solely on the model’s training data, it supplements it with real, dynamic business information—allowing it to give accurate and up-to-date answers.

By combining a high-quality language model with focused contextual data, we give our assistant the tools to reason, explain, and even summarize complex order information without writing a single SQL query.

Step 8: Question loop

With everything in place, the final step is to set up a simple interaction loop that allows users to engage with the assistant through natural language. This loop waits for a user’s input, processes the question, retrieves the most relevant data from Chroma, and generates an answer using Azure OpenAI.

The experience is intuitive—users don’t need to know SQL or the structure of the database. Instead, they can simply ask questions like:

• Which employee achieved the highest total unit sales?
• Which discounted products were the most frequently sold?
• Which customer purchased the widest variety of products?
• Which order had the highest overall value?
• Who processed the most orders in July 1996?

Behind the scenes, the assistant interprets the question, finds the best-matching entries from the embedded knowledge base, and composes a response based on actual transactional data.

# --- 8. Question loop ---
print("Ask me about any order from the Northwind database.")
while True:
    question = input("\nYour question: ")
    if question.lower() == "exit":
        break
    result = qa(question)
    print("\n Aswer:\n", result["result"])

This approach makes data exploration conversational. It lowers the barrier for interacting with structured information, opening new possibilities for customer support, sales analysis, and executive reporting—all through plain language.

At the end of this loop, we’ve built something more than just a chatbot. It’s a practical proof of concept showing how large language models can bring structured data to life in real time, transforming static records into dynamic, human-centered knowledge.

Northwind Assistant in Action: Sample Questions and Answers

This section showcases the assistant in action. By combining data from the Northwind database with Azure OpenAI and Chroma, we’ve built a system that understands natural language and responds with precise, contextual answers. Instead of writing complex SQL queries, users can now explore business insights simply by asking questions. Below are some example queries and the kind of intelligent responses the assistant is capable of generating.

Figure 6: User prompt asking which discounted products were sold the most.

Figure 7: AI-generated answer showing the top-selling products with discounts applied.

Figure 8: Natural language question about which order had the highest total value.

Figure 9: Response calculating and displaying the order with the highest overall value.

Conclusions

Combining SQL with LLMs unlocks new value from legacy data
By extracting and transforming structured information from a traditional database like Northwind, we demonstrated how even decades-old datasets can become fuel for modern AI-driven insights (without rewriting backend systems).

Semantic search enhances how we ask and answer questions
Using embeddings and a vector store (in this case, ChromaDB), the assistant is able to retrieve contextually relevant chunks of information instead of relying on rigid keyword matches. This allows for more flexible and intuitive interactions.

Natural language becomes the new interface for analytics
Thanks to Azure OpenAI’s chat capabilities, users no longer need to write complex SQL queries to understand data. Instead, they can simply ask questions in plain English (and get coherent answers backed by structured sources).

Modularity and scalability are built into the architecture
Each step of the assistant—data extraction, transformation, embedding, storage, and retrieval—is modular. This makes it easy to extend to new datasets, scale up in the cloud, or integrate into enterprise tools and workflows.

This approach bridges the gap between business users and data
Perhaps most importantly, this proof of concept shows that language models can act as intelligent intermediaries (allowing non-technical users to access meaningful insights from complex databases, instantly and conversationally).

References

Microsoft. (2024). What is Azure OpenAI Service? Microsoft Learn.
https://learn.microsoft.com/en-us/azure/ai-services/openai/overview

Chroma. (2024). ChromaDB: The AI-native open-source embedding database.
https://docs.trychroma.com/

OpenAI. (2024). Text embeddings documentation. OpenAI API Reference.
https://platform.openai.com/docs/guides/embeddings/what-are-embeddings

FutureSmart AI. (2024). ChromaDB: An open-source vector embedding database. FutureSmart AI Blog. https://blog.futuresmart.ai/chromadb-an-open-source-vector-embedding-database

FutureSmart AI. (2023). Master RAG with LangChain: A practical guide. FutureSmart AI Blog. https://blog.futuresmart.ai/master-rag-with-langchain-a-practical-guide

Jurafsky, D., & Martin, J. H. (2023). Speech and Language Processing (3rd ed., Draft). Stanford University. Retrieved from https://web.stanford.edu/~jurafsky/slp3/

Abstract

We live in a time when automating processes is no longer a luxury, but a necessity for any team that wants to remain competitive. But automation has evolved. It is  no longer just about executing repetitive tasks, but about creating solutions that understand context, learn over time, and make smarter decisions. In this blog, I want to show you how n8n (a visual and open-source automation tool) can become the foundation for building intelligent agents powered by AI.

We will explore what truly makes an agent “intelligent,” including how modern AI techniques allow agents to retrieve contextual information, classify tickets, or automatically respond based on prior knowledge.

I will also show you how to connect AI services and APIs from within a workflow in n8n, without the need to write thousands of lines of code. Everything will be illustrated with concrete examples and real-world applications that you can adapt to your own projects.

This blog is an invitation to go beyond basic bots and start building agents that truly add value. If you are exploring how to take automation to the next level, thiss journey will be of great interest to you.

Introduction

Automation has moved from being a trend to becoming a foundational pillar for development, operations, and business teams. But amid the rise of tools that promise to do more with less, a key question emerges: how can we build truly intelligent workflows that not only execute tasks but also understand context and act with purpose? This is where AI agents begin to stand out.

This blog was born from that very need. Over the past few months, I’ve been exploring how to take automation to the next level by combining two powerful elements: n8n (a visual automation platform) and the latest advances in artificial intelligence. This combination enables the design of agents capable of understanding, relating, and acting based on the content they receive—with practical applications in classification, search, personalized assistance, and more.

In the following sections, I’ll walk you through how these concepts work, how they connect with each other, and most importantly, how you can apply them yourself (without needing to be an expert in machine learning or advanced development). With clear explanations and real-world examples built with n8n, this blog aims to be a practical, approachable guide for anyone looking to go beyond basic automation and start building truly intelligent solutions.

What are AI Agents?

An AI agent is an autonomous system (software or hardware) that perceives its environment, processes information, and makes decisions to achieve specific goals. It does not merely react to basic events; it can analyze context, query external sources, and select the most appropriate action. Unlike traditional bots, intelligent agents integrate reasoning and sometimes memory, allowing them to adapt and make decisions based on accumulated experience (Wooldridge & Jennings, 1995; Cheng et al., 2024).

In the context of n8n, an AI agent translates into workflows that not only execute tasks but also interpret data using language models and act according to the situation, enabling more intelligent and flexible processes.

From Predictable to Intelligent: Traditional Bot vs. Context-Aware AI Agent

A traditional bot operates based on a set of rigid rules and predefined responses, which limits its ability to adapt to unforeseen situations or understand nuances in conversation. Its interaction is purely reactive: it responds only to specific commands or keywords, without considering the conversation’s history or the context in which the interaction occurs. In contrast, a context-aware artificial intelligence agent uses advanced natural language processing techniques and conversational memory to adapt its responses according to the flow of the conversation and the previous information provided by the user. This allows it to offer a much more personalized, relevant, and coherent experience, overcoming the limitations of traditional bots. Context-aware agents significantly improve user satisfaction, as they can understand intent and dynamically adapt to different conversational scenarios (Chen, Xu, & Wang, 2022).

Figure 1: Architecture of an intelligent agent with hybrid memory in n8n (Dąbrowski, 2024).

How Does n8n Facilitate the Creation of Agents?

n8n is an open-source automation platform that enables users to design complex workflows visually, without the need to write large amounts of code. It simplifies the creation of intelligent agents by seamlessly integrating language models (such as OpenAI or Azure OpenAI), vector databases, conditional logic, and contextual memory storage.

With n8n, an agent can receive text input, process it using an AI model, retrieve relevant information from a vector store, and respond based on conversational history. All of this is configured through visual nodes within a workflow, making advanced solutions accessible even to those without a background in artificial intelligence.

Thanks to its modular and flexible design, n8n has become an ideal platform for building agents that not only automate tasks but also understand, learn, and act autonomously.

Figure 2: Automated workflow in n8n for onboarding and permission management using Slack, Jira, and ServiceNow (TextCortex, 2025).

Integrations with OpenAI, Python, External APIs, and Conditional Flows

One of n8n’s greatest strengths is its ability to connect with external tools and execute custom logic. Through native integrations, it can interact with OpenAI (or Azure OpenAI), enabling the inclusion of language models for tasks such as text generation, semantic classification, or automated responses.

Additionally, n8n supports custom code execution through Python or JavaScript nodes, expanding its capabilities and making it highly adaptable to different use cases. It can also communicate with any external service that provides a REST API, making it ideal for enterprise-level integrations.

Lastly, its conditional flow system allows for dynamic branching within workflows, evaluating logical conditions in real time and adjusting the agent’s behavior based on the context or incoming data.

Figure 3: Basic conversational agent flow in n8n with language model and contextual memory.

This basic flow in n8n represents the core logic of a conversational intelligent agent. The process begins when a message is received through the “When chat message received” node. That message is then passed to the AI Agent node, which serves as the central component of the system.

The agent is connected to two key elements: a language model (OpenAI Chat Model) that interprets and generates responses, and a simple memory that allows it to retain the context or conversation history. This combination enables the agent not only to produce relevant responses but also to remember previous information and maintain coherence across interactions.

This type of architecture demonstrates how, with just a few nodes, it is possible to build agents with contextual behavior and basic reasoning capabilities—ideal for customer support flows, internal assistants, or automated conversational interfaces.

Before the agent can interact with users, it needs to be connected to a language model. The following shows how to configure this integration in n8n.

Configuring the Language Model in the AI Agent

As developers at Perficient, we have the advantage of accessing OpenAI services through the Azure platform. This integration allows us to leverage advanced language models in a secure, scalable manner, fully aligned with corporate policies, and facilitates the development of artificial intelligence solutions tailored to our needs.

One of the fundamental steps in building an AI agent in n8n is to define the language model that will be used to process and interpret user inputs. In this case, we use the OpenAI Chat Model node, which enables the agent to connect with advanced language models available through the Azure OpenAI API.

When configuring this node, n8n will require an access credential, which is essential for authenticating the connection between n8n and your Azure OpenAI service. If you do not have one yet, you can create it from the Azure portal by following these steps:

• Go to the Azure portal. If you do not yet have an Azure OpenAI resource, create one by selecting “Create a resource“, searching for “Azure OpenAI”, and following the setup wizard to configure the service with your subscription parameters. Then access the implemented resource.
• Go to url https://ai.azure.com and sign in with your Azure account. Select the Azure OpenAI resource you created and, from the side menu, navigate to the “Deployments” section. There you must create a new deployment, selecting the language model you want to use (for example, GPT 3.5 or GPT 4) and assigning it a unique deployment name. You can also click on the Command-Go to Azure AI Foundry portal option as shown in the image.

Figure 4: Access to the Azure AI Foundry portal from the Azure OpenAI resource.

• Once the deployment is created, go to “API Keys & Endpoints” to copy the access key (API Key) and the endpoint corresponding to your resource.

Figure 5: Visualization of model deployments in Azure AI Foundry.

Once the model deployment has been created in Azure AI Foundry, it is essential to access the deployment details in order to obtain the necessary information for integrating and consuming the model from external applications. This view provides the API endpoint, the access key (API Key), as well as other relevant technical details of the deployment, such as the assigned name, status, creation date, and available authentication parameters.

This information is crucial for correctly configuring the connection from tools like n8n, ensuring a secure and efficient integration with the language model deployed in Azure OpenAI.

Figure 6: Azure AI Foundry deployment and credentialing details.

• Step 1:

  In n8n, select the “+ Create new credential” option in the node configuration, and enter the endpoint, the API key, and the deployment name you configured. But first we must create the AI Agent:

Figure 7: Chat with AI Agent.

Step 2:

After the creation of the Agent, the model is added, as shown in the figure above. Within the n8n environment, integration with language models is accomplished through specialized nodes for each AI provider.

To connect our agent with Azure OpenAI services, it is necessary to select the Azure OpenAI Chat Model node in the Language Models section.

This node enables you to leverage the advanced capabilities of language models deployed in Azure, making it easy to build intelligent and customizable workflows for various corporate use cases. Its configuration is straightforward and, once properly authenticated, the agent will be ready to process requests using the selected model from Azure’s secure and scalable infrastructure.

Figure 8: Selection of the Azure OpenAI Chat Model node in n8n.

Step 3:

Once the Azure OpenAI Chat Model node has been selected, the next step is to integrate it into the n8n workflow as the primary language model for the AI agent.

The following image illustrates how this model is connected to the agent, allowing chat inputs to be processed intelligently by leveraging the capabilities of the model deployed in Azure. This integration forms the foundation for building more advanced and personalized conversational assistants in enterprise environments.

Figure 9: Selection of the Azure OpenAI Chat Model node in n8n.

Step 4:

When configuring the Azure OpenAI Chat Model node in n8n, it is necessary to select the access credential that will allow the connection to the Azure service.

If a credential has not yet been created, you can do so directly from this panel by selecting the “Create new credential” option.

This step is essential to authenticate and authorize the use of language models deployed in Azure within your automation workflows.

Figura 10: Selection of the Azure OpenAI Chat Model node in n8n.

Step 5:

To complete the integration with Azure OpenAI in n8n, it is necessary to properly configure the access credentials.

The following screen shows the required fields, where you must enter the API Key, resource name, API version, and the corresponding endpoint.

This information ensures that the connection between n8n and Azure OpenAI is secure and functional, enabling the use of language models deployed in the Azure cloud.

Figure 11: Azure OpenAI credentials configuration in n8n.

Step 6:

After creating and selecting the appropriate credentials, the next step is to configure the model deployment name in the Azure OpenAI Chat Model node.

In this field, you must enter exactly the name assigned to the model deployment in Azure, which will allow n8n to correctly use the deployed instance to process natural language requests. Remember to select the Model of the selected implementation in Azure OpenIA, in this case gtp-4.1-mini:

Figure 12: Configuration of the deployment name in the Azure OpenAI Chat Model node.

Step 7:

Once the language model is connected to the AI agent in n8n, you can enhance its capabilities by adding memory components.

Integrating a memory system allows the agent to retain relevant information from previous interactions, which is essential for building more intelligent and contextual conversational assistants.

In the following image, the highlighted area shows where a memory module can be added to enrich the agent’s behavior.

Figure 13: Connecting the memory component to the AI agent in n8n.

Step 8:

To start equipping the AI agent with memory capabilities, n8n offers different options for storing conversation history.

The simplest alternative is Simple Memory, which stores the data directly in n8n’s internal memory without requiring any additional credentials.

There are also more advanced options available, such as storing the history in external databases like MongoDB, Postgres, or Redis, which provide greater persistence and scalability depending on the project’s requirements.

Figure 14: Memory storage options for AI agents in n8n.

Step 9:

The configuration of the Simple Memory node in n8n allows you to easily define the parameters for managing the conversational memory of the AI agent.

In this interface, you can specify the session identifier, the field to be used as the conversation tracking key, and the number of previous interactions the model will consider as context.

These settings are essential for customizing information retention and improving continuity in the user’s conversational experience.

Figure 15: Memory storage options for AI agents in n8n.

Step 10:

The following image shows the successful execution of a conversational workflow in n8n, where the AI agent responds to a chat message using a language model deployed on Azure and manages context through a memory component.

You can see how each node in the workflow performs its function and how the conversation history is stored, enabling the agent to provide more natural and contextual responses.

Figure 16: Execution of a conversational workflow with Azure OpenAI and memory in n8n.

Once a valid credential has been added and selected, the node will be ready to send requests to the chosen language model (such as GPT 3.5 or GPT 4) and receive natural language responses, allowing the agent to continue the conversation or execute actions automatically.

With this integration, n8n becomes a powerful automation tool, enabling use cases such as conversational assistants, support bots, intelligent classification, and much more.

Integration of the AI agent into the web application through an n8n workflow triggered by a webhook.

Before integrating the AI agent into a web application, it is essential to have a ready-to-use n8n workflow that receives and responds to messages via a Webhook. Below is a typical workflow example where the main components for conversational processing are connected.

For the purposes of this blog, we will assume that both the Webhook node (which receives HTTP requests) and the Set/Edit Fields node (which prepares the data for the agent) have already been created. As shown in the following image, the workflow continues with the configuration of the language model (Azure OpenAI Chat Model), memory management (Simple Memory), processing via the AI Agent node, and finally, sending the response back to the user using the Respond to Webhook node.

Figure 17: n8n Workflow for AI Agent Integration with Webhook.

Before connecting the web interface to the AI agent deployed in n8n, it is essential to validate that the Webhook is working correctly. The following image shows how, using a tool like Postman, you can send an HTTP POST request to the Webhook endpoint, including the user’s message and the session identifier. As a result, the flow responds with the message generated by the agent, demonstrating that the end-to-end integration is functioning properly.

Figure 18: Testing the n8n Webhook with Postman.

1. 1. Successful Test of the n8n Chatbot in a WebApp: The following image shows the functional integration between a chatbot built in n8n and a custom web interface using Bootstrap. By sending messages through the application, responses from the AI agent deployed on Azure OpenAI are displayed in real time, enabling a seamless and fully automated conversational experience directly from the browser.
      
      Figure 19: n8n Chatbot Web Interface Working with Azure OpenAI.
      

   2. Introductory Text: Before consuming the agent from a web page or an external application, it is essential to ensure that the flow in n8n is activated. As shown in the image, the “Active” button must be enabled (green) so that the webhook works continuously and can receive requests at any time. Additionally, remember that when deploying to a production environment, you must change the webhook URL, using the appropriate public address instead of “localhost”, ensuring external access to the flow.

      
      Figure 20: Activation and Execution Tracking of the Flow in n8n.

Conclusions

Intelligent automation is essential for today’s competitiveness

Automating tasks is no longer enough; integrating intelligent agents allows teams to go beyond simple repetition, adding the ability to understand context, learn from experience, and make informed decisions to deliver real value to business processes.

Intelligent agents surpass the limitations of traditional bots

Unlike classic bots that respond only to rigid rules, contextual agents can analyze the flow of conversation, retain memory, adapt to changing situations, and offer personalized and coherent responses, significantly improving user satisfaction.

n8n democratizes the creation of intelligent agents

Thanks to its low-code/no-code approach and more than 400 integrations, n8n enables both technical and non-technical users to design complex workflows with artificial intelligence, without needing to be experts in advanced programming or machine learning.

The integration of language models and memory in n8n enhances conversational workflows

Easy connection with advanced language models (such as Azure OpenAI) and the ability to add memory components makes n8n a flexible and scalable platform for building sophisticated and customizable conversational agents.

Proper activation and deployment of workflows ensures the availability of AI agents

To consume agents from external applications, it is essential to activate workflows in n8n and use the appropriate production endpoints, thus ensuring continuous, secure, and scalable responses from intelligent agents in real-world scenarios.

References

• Wooldridge, M., & Jennings, N. R. (1995). Intelligent agents: Theory and practice. The Knowledge Engineering Review, 10(2), 115–152.
• Cheng, Y., Zhang, C., Zhang, Z., Meng, X., Hong, S., Li, W., Zhao, J. (2024). Exploring Large Language Model based Intelligent Agents: Definitions, Methods, and Prospects. arXiv.
• Chen, C., Xu, Y., & Wang, Z. (2022). Context-Aware Conversational Agents: A Review of Methods and Applications. IEEE Transactions on Artificial Intelligence, 3(4), 410-425.
• Zamani, H., Sadoughi, N., & Croft, W. B. (2023). Intelligent Workflow Automation: Integrating Memory-Augmented Agents in Business Processes. Journal of Artificial Intelligence Research, 76, 325-348.
• Dąbrowski, D. (2024). Day 67 of 100 Days Agentic Engineer Challenge: n8n Hybrid Long-Term Memory. Medium. https://damiandabrowski.medium.com/day-67-of-100-days-agentic-engineer-challenge-n8n-hybrid-long-term-memory-ce55694d8447
• n8n. (2024). Build your first AI Agent – powered by Google Gemini with memory. https://n8n.io/workflows/4941-build-your-first-ai-agent-powered-by-google-gemini-with-memory
• Luo, Y., Liang, P., Wang, C., Shahin, M., & Zhan, J. (2021). Characteristics and challenges of low code development: The practitioners’ perspective. arXiv. http://dx.doi.org/10.48550/arXiv.2107.07482
• TextCortex. (2025). N8N Review: Features, pricing & use cases. Cybernews. https://cybernews.com/ai-tools/n8n-review/

Flutter is powerful — but let’s be honest, it often involves a lot of repetitive boilerplate and wiring.

Enter GitHub Copilot: your AI-powered pair programmer that lives right in your IDE and helps you write better Flutter code, faster.

Why Use GitHub Copilot for Flutter?

Flutter development often involves:

• Repetitive UI patterns
• Business logic & state management
• API handling
• Testing

Copilot accelerates all of these by offering smart, context-aware code suggestions that adapt to your file’s content and project structure.

8 Top Use Cases in Flutter with Copilot

1. Copilot Uses In-File Context to Complete Logic

Copilot reads your actual code and completes functions based on the context.

Example

If you already have a User model:

class User {

  final String name, email;

  factory User.fromJson(Map<String, dynamic> json) =>

      User(name: json['name'], email: json['email']);

}

Then type:

Future<User> fetchUser() async {

Copilot suggests the entire fetch method using the model.

Demo attached below – See how Copilot completes the fetchUser() method by analyzing the existing User Model in your file.

Copilot Suggests:

Future<User> fetchUser() async { 
 final response = await http.get(Uri.parse('https://api.example.com/user')); 
 if (response.statusCode == 200) {  
  return User.fromJson(jsonDecode(response.body)); 
 } else { 
   throw Exception('Failed to load user');
  }
}

 2. Predicts Widget Behaviour Based on Methods in Scope

Define:

void _submitLoginForm() {}

Then type inside a widget:

ElevatedButton(

  onPressed: () {

Copilot completes it as:

_submitLoginForm();

  },

  child: Text('Login'),

)

Demo below – On the Submit Call, Copilot predicts the button’s onPressed behavior automatically:

3. Auto-Generate UI Widgets

Prompt:

// A login form with email and password fields

Demo attached – Prompt Copilot with // Login form, and it generates complete UI code:

Copilot Suggests:

Column(

  children: [

    TextFormField(decoration: InputDecoration(labelText: 'Email')),

    TextFormField(obscureText: true, decoration: InputDecoration(labelText: 'Password')),

    ElevatedButton(onPressed: () {}, child: Text('Login')),

  ],

)

4. Build StatefulWidgets Faster

Just start typing the class, and Copilot fills in:

• createState()
• initState()
• build()

5. Write Provider/Bloc/Riverpod Logic

Prompt:

// A ChangeNotifier for managing a counter

Demo – From a simple comment like // Counter provider Copilot writes a full ChangeNotifier class

class CounterProvider with ChangeNotifier {

  int _count = 0;

  int get count => _count;

  void increment() {

    _count++;

    notifyListeners();

  }

}

6. Model Classes from JSON

Prompt:

// A User model from JSON

Demo attached – Copilot generates a full Dart model from a JSON comment:

Copilot Suggests:

class User {

  final String name, email;

  User({required this.name, required this.email});

  factory User.fromJson(Map<String, dynamic> json) =>

    User(name: json['name'], email: json['email']);

}

7. Service Classes for API Calls

Prompt:

// A service that fetches user data from an API

Copilot Suggests:

Future<User> fetchUser() async {

  final response = await http.get(Uri.parse('https://api.example.com/user'));

  if (response.statusCode == 200) {

    return User.fromJson(jsonDecode(response.body));

  } else {

    throw Exception('Failed to load user');

  }

}

8. Write Unit & Widget Tests

Prompt:

testWidgets(‘displays login button’, (tester) async {

Copilot Suggests:

await tester.pumpWidget(MyApp());

expect(find.text(‘Login’), findsOneWidget);

Real Productivity Boost: Copilot vs. Manual Coding

To show real-world time savings, let’s compare creating a To-Do App manually vs. with Copilot:

Without Copilot

• Create model (fromJson, toJson): 10–15 min
• UI for tasks, forms: 20–30 min
• State management: 25–35 min
• Validation logic: 20–30 min
• API handling: 20–30 min
• Write widget tests: 25–40 min

Total: ~2.5 – 3.5 hours

With Copilot

• Model + JSON: 2–3 min
• UI suggestion from the prompt: 5–10 min
• State class: 5–7 min
• Form validation: 5–10 min
• API methods: 5–10 min
• Tests: 10-15 min

Total: ~45 – 60 minutes

Net Savings: ~65–75% Time Reduction

Copilot handles the repetitive patterns, so you focus on the important stuff — app behavior, UX, performance.

What About GitHub Copilot Agents?

GitHub recently introduced Copilot Agents — an evolution beyond autocomplete. These agents can perform multi-step tasks like:

• Editing your code across multiple files
• Creating new files based on a request
• Generating tests automatically
• Finding and fixing bugs
• Explaining complex code in natural language

How This Helps Flutter Devs

Imagine asking:

“Create a SettingsScreen with toggle switches for dark mode and notifications, wired to a provider.”

And Copilot Agent could:

• Create settings_screen.dart
• Generate SettingsProvider
• Wire everything up
• Add routing to main.dart

Demo Attached:

Pro Tips to Get the Best From Copilot

Do This:

• Use clear, descriptive comments
  e.g., // Login form, // Provider for user data

• Accept Copilot suggestions in small, manageable chunks

• Refactor as you go — extract widgets and name classes meaningfully

• Use linters and formatters (flutter_lints, dart format)

• Combine Copilot with Hot Reload or Flutter DevTools to preview changes quickly

Avoid This:

• Writing vague comments like // something — Copilot won’t understand the intent

• Accepting long code blocks without reviewing them

• Skipping quality checks and formatting

• Accepting the code without testing or visual validation

Know the Limits

• May generate inefficient widget trees
• Doesn’t understand custom plugins deeply
• Can’t replace performance tuning or design reviews

Final Thoughts

GitHub Copilot is like a smart Flutter intern — fast, intuitive, and surprisingly useful. Whether you’re building a UI, creating a provider, or scaffolding a test, Copilot boosts your development speed without sacrificing code quality.

And with Copilot Agents on the horizon, AI-assisted Flutter development is only just getting started.

What is Databricks Lakebase?

Databricks Lakebase is a Postgres OLTP engine, integrated into Databricks Data Intelligence Platform. A database instance is a compute type that provides fully managed storage and compute resources for a postgres database. Lakebase leverages an architecture that separates compute and storage, which allows independent scaling while supporting low latency (<10ms) and high concurrency transactions.

Databricks has integrated this powerful postgres engine along with sophisticated capabilities that are benefited by Databricks recent acquisition of Neon. Lakebase is fully managed by Databricks, which means no infrastructure has to be provisioned and maintained separately. In addition to traditional OLTP engine, Lakebase comes with below features,

• Openness: Lakebase are built on open-source standards
• Storage and compute separation: Lakebase stores data in data lakes in open format. It enables scaling storage and compute independently.
• Serverless: Lakebase is lightweight, meaning it can scale instantly up and down based on the load. It can scale down to zero, at which the cost of the lakebase is just for the storage  of data only. No compute cost will be applied.
• Modern development workflow: Branching a database is as simple as branching a code repository. It is done near instantly.
• Built for AI Agents: Lakebases are designed to support a large number of AI agents. It’s branching and checkpointing capabilities enable AI agents to experiment and rewind to any point in time.
• Lakehouse Integration: Lakebase make it easy to combine operational, analytical and AI systems without complex ETL pipelines.

In this article, we shall discuss in detail about how database branching feature works in Lakebase.

Database Branching

Database branching is one of the unique features introduced in Lakebase, that enables to branch out a database. It resembles the exact behavior of how code branch could be branched out from an existing branch.

Branching database is beneficial for an isolated test environment or point in time recovery. Lakebase uses copy-on-write branching mechanism to create an instant zero-copy clone of the database, with dedicated compute to operate on that branch. With zero-copy clone, it enables to create a branch of parent database of any size instantly.

The child branch is managed independently of the parent branch. With child isolated database branch, one can perform testing/debugging in the production copy of data. Though both parent and child databases appear separate, physically both instances would be pointing to same data pages. Under the hood, child database will be pointing to the actual data pages which parent is pointing to. When a change occurs in any of the data in child branch, then a new data page will be created with the new changes, and it will be available only to the branch. Any changes done in branch will not reflect in parent branch.

How branching works

The below diagrams represent how database branching works under the hood,

Lakebase in action

Here is the demonstration of how Lakebase instance can be created, branch out an instance and how table changes behave,

To create Lakebase instance, login Databricks and navigate to Compute -> OLTP Database tab -> Click “Create New Instance” button,

Click “New Query” to launch SQL Editor for PostgreSQL Database. In current instance, let’s create a new table and add some records.

Let’s create a database branch “pginstance2” from instance “pginstance1”. Goto Compute –> OLTP Database –> Create Database instance

Enter new instance name and expand “Advanced Settings” -> Enable “Create from parent” option -> Enter the source instance name “pginstance1”.

Under “Include data from parent up to”, select “Current point in time” option. Here, we can choose any specific point in time instance too.

Launch SQL Editor from pginstance2 database instance and query tbl_user_profile table

Now, let’s insert new record and update an existing record in the tbl_user_profile table in pginstance2,

Now, let’s switch back to parent database instance pginsntance1 and query tbl_user_profile table. The table in pginsntance1 should still be only 3 records. All the changes done in tbl_user_profile table should be available only in pginstance2.

Conclusion

Database changes that are done in one branch will not impact/reflect in another branch, thereby provide clear isolation of database at scale. Currently Lakebase do not have a feature to merge database branch. However, Databricks is committed and working towards database merge capability in near future.

We’re excited to welcome Bamidele James as Perficient’s newest and third Databricks Champion!  His technical expertise, community engagement, advocacy, and mentorship have made a profound impact on the Databricks ecosystem.

His Nomination Journey

Bamidele’s journey through the nomination process was vigorous. It required evidence that he has successfully delivered multiple Databricks projects, received several certifications, completed an instructor-led training course, and participated in a panel interview with the Databricks committee.

What This Achievement Means

This achievement represents peer and leadership recognition of Bamidele’s knowledge, contributions, and dedication to building strong partnerships. It also brings him a sense of purpose and pride to know that his work has made a real impact, and his continuous efforts are appreciated.

Contributing to Databricks’ and Perficient’s Growth

Bamidele plays a pivotal role in helping our clients unlock the full potential of Databricks by aligning Perficient’s Databricks capabilities with their business goals. He enables enterprise customers to accelerate their data and AI transformation to deliver measurable outcomes like reduced time-to-insight, improved operational efficiency, and increased revenue. In addition, Bamidele has led workshops, held executive briefings, and developed proof of concepts that help our clients drive adoption and deepen customer engagement.

“Being a Databricks Champion affirms that my contributions, knowledge, and dedication to building strong partnerships are recognized by my peers and leadership.” – Bamidele James, Technical Architect

 Skills Key to This Achievement

Many skills and proficiencies—including data engineering and architecture, machine learning and AI, cloud platforms, data governance and security, solution selling, stakeholder management, and strategic thinking—played a part in Bamidele becoming a Databricks Champion. To anyone wishing to follow a similar path, Bamidele recommends mastering the platform, attaining deep technical expertise, and focusing on real-world impact.

Looking Ahead

Bamidele looks forward to using Databricks to create innovative tools and solutions that drive success for our clients. He’s also excited about trends and Databricks innovations including multi-tab notebooks, Databricks Lake Flow, the new SQL interface, and SQL pipeline syntax.

Perficient + Databricks

Perficient is proud to be a trusted Databricks elite consulting partner with more than 130 certified consultants. We specialize in delivering tailored data engineering, analytics, and AI solutions that unlock value and drive business transformation.

Learn more about our Databricks partnership.

When using cloud-based event-driven systems, it’s essential to respond to changes at the storage level, such as when files are added, modified, or deleted. Google Cloud Platform (GCP) makes this easy by enabling Cloud Storage and Pub/Sub to talk to one another directly. This arrangement lets you send out structured real-time alerts whenever something happens inside a bucket. This configuration is specifically designed to catch deletion occurrences. When a file is deleted from a GCS bucket, a message is sent to a Pub/Sub topic. That subject becomes the main connection, providing alerts to any systems that are listening, such as a Cloud Run service, an external API, or another microservice. These systems can then react by cleaning up data, recording the incident, or sending out alarms. The architecture also takes care of critical backend needs. It employs IAM roles to set limits on who can access what, has retry rules in case something goes wrong for a short time, and links to a Dead-Letter Queue (DLQ) to keep messages that couldn’t be sent even after numerous tries. The whole system stays loosely coupled and strong because it employs technologies that are built into GCP. You can easily add or remove downstream services without changing the initial bucket. This pattern is a dependable and adaptable way to enforce cleanup rules, track changes for auditing, or initiate actions in real-time. In this article, we’ll explain the fundamental ideas, show you how to set it up, and talk about the important design choices that make this type of event notification system work with Pub/Sub to keep everything running smoothly.

Why Use Pub/Sub for Storage Notifications?

Pub/Sub makes it easy to respond to changes in Cloud Storage, like when a file is deleted, without having to connect everything closely. You don’t link each service directly to the storage bucket. Instead, you send events using Pub/Sub. This way, logging tools, data processors, and alarm systems may all work on their own without interfering with each other. The best thing? You can count on it. Even if something goes wrong, Pub/Sub makes sure that events don’t get lost. And since you only pay when messages are delivered or received, you don’t have to pay for resources that aren’t being used. This setup lets you be flexible, respond in real time, and evolve, which is great for cloud-native systems that need to be able to adapt and stay strong.

Architecture Overview

Step 1: Create a Cloud Storage Bucket

If you don’t already have a bucket, go to the Cloud Storage console, click ‘Create Bucket’, and follow these steps:
– Name: Choose a globally unique bucket name (e.g., demopoc-pubsub)
– Location: Pick a region or multi-region
– Default settings: You can leave the rest unchanged for this demo

Step 2: Create a Pub/Sub Topic

Go to Pub/Sub in the Cloud Console and:
1. Click ‘Create Topic’
2. Name it something like demo-poc-pubsub
3. Leave the rest as defaults
4. Click Create

Step 3: Create a Pub/Sub Subscription (Pull-based)

1. Click on the topic gcs-object-delete-topic
   2. Click ‘Create Subscription’
   3. Choose a pull subscription
   4. Name it gcs-delete-sub
   5. Leave other options as default
   6. Click Create

Step 4: Grant Pub/Sub Permission to Publish to the Topic

Go to the IAM permissions for your topic:
1. In the Pub/Sub console, go to your topic
2. Click ‘Permissions’
3. Click ‘Grant Access’
4. Add the GCS service account: service-<project-number-sample>@gs-project-accounts.iam.gserviceaccount.com
5. Assign it the role: Pub/Sub Publisher
6. Click Save

Step 5: Connect Cloud Storage to Pub/Sub via Shell

Open your cloud shell terminal and run:

gcloud storage buckets notifications create gs://my-delete-audit-bucket –topic=gcs-object-delete-topic –event-types=OBJECT_DELETE –payload-format=json

Explanation of gsutil command:

 gs://my-delete-audit-bucket: Your storage bucket

–topic: Pub/Sub topic name

–event-types=OBJECT_DELETE: Triggers only when objects are deleted

–payload-format=json: Format of the Pub/Sub message

Step 6: Test the Notification System
Then pull the message from Pub/Sub console.

Expected message payload:
{
“kind”: “storage#object”,
“bucket”: “my-delete-audit-bucket”,
“name”: “test.txt”,
“timeDeleted”: “2025-06-05T14:32:29.123Z”
}

Sample Use Cases

1. Audit Trail for Object Deletion Use Case: Keep track of every deletion for compliance or internal audits.        How it works:When a file is destroyed, the Cloud Storage trigger sends an event to Pub/Sub. A Cloud Function or Dataflow task subscribes to the topic and sends metadata (such as the file name, timestamp, user, and bucket) to Big-Query.Why it matters:
   Keeps an unchangeable audit trail, helps with compliance (such HIPAA and SOC2), security audits, and internal investigations.
   
   Enforcement of Data Retention

   Use Case: Stop people from accidentally deleting data or make sure that data is kept for at least a certain amount of time.How it works:

   When an object is deleted, the system checks to see if it should have been deleted based on its name, metadata, and other factors.
   It logs the incident or restores the object from backup (for example, using Nearline or Archive tier) if it finds a violation.

   Why it matters:

   Helps keep data safe from being lost because to accidental or unlawful deletion. Makes sure that data lifecycle policies are followed

   3. Start cleaning jobs downstream

   Use Case: When an object is removed, connected data in other systems should be cleaned away automatically.How it works:

   When you delete a GCS object, a Cloud Function or Dataflow pipeline is triggered by the Pub/Sub message. This job deletes records that are linked to it in Big-Query, Fire-store, or invalidates cache/CDN entries.

   Why it matters:
   Keeps data systems working together. Stops recordings from being left behind or metadata from getting old

   4. Alerts in Real Time

   Use Case: Let teams or monitoring systems know when sensitive or unexpected removals happen.How it works:

   A Cloud Function that listens to Pub/Sub looks at the event. It gives an alert if the deletion meets certain criteria, such as a certain folder or file type.

Why it matters
Allows for a response in real time. Increases the ability to see high-risk operations

Result:

We created a modular, fault-tolerant real-time event-driven pipeline by using a Pub/Sub-based notification system for deleting Cloud Storage objects. When an object is added to or removed from the specified GCS bucket, alert notifications are sent to a Pub/Sub topic. That topic makes sure that the message gets to one or more downstream consumers.

Conclusion

Combining Cloud Storage with Pub/Sub for deleting objects is a basic idea in today’s GCP design. It publishes events to a Pub/Sub topic in almost real time when something is deleted. These events can be used for audit trails, enforcing data policies, automatic cleanups, and even alarms.This method promotes loose coupling by enabling Cloud Storage send events without having to know who the subscribers are. Cloud Functions, Dataflow, and custom applications that subscribers use can handle messages on their own. This makes the system easier to scale and manage.Using pub/sub makes production workflows more organized because it adds reliability, parallelism, retries, and other benefits. If GCP engineers want to design cloud systems that are adaptable, responsive, and ready for the future, they need to be experts at event-driven integration.

What’s it like to receive a phone call to say, “I need you to quickly transfer some funds,” and that person sounds just like your boss, but it is not your boss? Or somebody constructing a complete and realistic video of you stating something you never said? This is not science fiction,  this is reality and the domain of synthetic identities and deepfake threats, and it is quickly becoming the norm.

Earlier, I wrote about this growing threat in my blog, AI-Powered Voice & Video Scams, when I presented a few real-world examples of how scammers are taking advantage of AI tools to impersonate someone’s voice or make videos. This blog is intended to build upon that awareness to articulate synthetic identities and deepfakes and what you can do to protect yourself from them.

What Are Synthetic Identities?

Synthetic identity fraud happens when attackers combine real and fake information to create a new, fictitious identity. For example:

• They might use a real Social Security Number / Aadhaar Number (often stolen from a child or elderly person) with a fake name, date of birth, and address.

• This synthetic profile looks legitimate enough to pass many automated checks and can be used to open bank accounts, apply for credit cards, or commit other financial crimes.

Synthetic identities are hard to detect because:

• They’re not linked to real people in a way that raises immediate red flags.
• Credit bureaus might create a new file when they see a new combination of data.
• Victims often don’t find out until years later.

What Are Deepfakes?

Deepfakes are AI-generated fake media — photos, videos, or audio that convincingly imitate real people’s faces, voices, or gestures.
They use deep learning, a type of artificial intelligence, to swap faces, mimic voices, or make someone appear to say or do something they never did.

Deepfake technology has advanced so much that:

• Videos can look extremely realistic even to trained eyes.

• Voice deepfakes can clone a person’s speech with just a few minutes of audio.

• Tools to create deepfakes are publicly available online.

Common Terms Explained

1. Synthetic Identity – A fake identity made by combining real and fake information.
2. Deepfake – AI-created fake images, videos, or audio imitating real people.
3. Voice Cloning – Using AI to generate speech in a specific person’s voice.
4. Social Engineering – Psychological tricks to manipulate people into giving up confidential information or doing something harmful.
5. Phishing – Fraudulent messages (email, text, calls) pretending to be from trusted sources to steal data or money.
6. Verification – The process of proving someone’s identity (e.g., 2FA, biometrics).

Why Are These Threats So Dangerous?

• For individuals: Criminals can blackmail people with fake videos, ruin reputations, or commit identity theft.

• For businesses: Deepfakes can impersonate executives in phishing attacks, trick employees into transferring funds, or manipulate stock prices with fake announcements.

• For society: Deepfakes can spread misinformation during elections, fuel conspiracy theories, and undermine trust in media.

How Can You Protect Yourself?

For Individuals:

• Be skeptical of unexpected calls, emails, or messages — especially those involving money or personal information.

• Use multi-factor authentication (MFA) wherever possible.

• Regularly check your credit report for suspicious accounts.

• Keep your social media privacy settings tight to limit voice or photo samples available to attackers.

For Businesses:

• Educate employees about deepfake and social engineering scams.

• Implement strict verification processes for financial transactions (e.g., callbacks on a trusted number).

• Use tools that can detect deepfakes — several companies offer AI-powered detection solutions.

• Monitor social media and news outlets for fake content involving your brand or executives.

For Everyone:

• Promote awareness — the more people know about these threats, the harder it becomes for attackers to succeed.

Conclusion

Synthetic identities and deepfakes aren’t futuristic ideas — they’re real threats today, and they’re only getting more sophisticated. By understanding how they work and taking proactive measures, we can better prepare ourselves, our families, and our organizations for this new normal.

Stay alert, verify everything, and help spread awareness — because the best defense against deception is education.

AI is no longer the future; it is happening. Every other technology faces issues during its development phase, and AI is no exception. Have you ever asked an AI a question and received an answer that sounded perfectly confident, only to find out it was completely wrong? That is not a glitch; it is called hallucination in the world of AI.

What Are AI Hallucinations?

An AI hallucination occurs when a model produces content that seems accurate but is incorrect, fabricated, illogical, or nonsensical. The result might appear correct, but it’s simply not true, deviating from the fact.

Why do AI Hallucinations Occur?

To understand AI hallucinations, we need to take a look under the hood at how these models are designed, trained, and deployed for customer use.

• Language prediction, not reasoning: Certain generative AIs are just trained to predict the next word in a sentence based on patterns in massive text datasets.
• No awareness: These models lack understanding, but they can only mimic.
• Gaps in training data: If a model has not been exposed to sufficient reliable information, if the training data is biased, or if it has been trained with very limited data, the result may deviate from the actual truth.
• Overconfidence: AI models are optimized for fluency and clarity, which can lead them to present wrong answers in an authoritative tone.

Understand with a Real-World Example

Let us consider the following example. Here, the user asks AI a question and receives a result, then rephrases the question to maintain the same meaning, but this time, AI generates a different answer in contradiction to the previous one. This inconsistency and lack of clarity lead to AI hallucination.

The user asks, “Is Pluto a planet?”

AI says, “Yes, Pluto is the 9th planet.”

The user rephrases the question and asks again, and AI says, “No, Pluto is not a planet since it does not clear its orbital path of other debris.”

AI can hallucinate in terms of fake citations on websites, books, legal or research documents, historical inaccuracies, visual errors in image generation, and contradictory responses, among other issues. In critical fields like banking, healthcare, law, or education, such hallucinations can be lethal.

How to Spot an AI Hallucination

• Check with external authentic sources: If something seems right but still triggers ambiguity, perform a fact-check with authenticated sources, either online or offline.
• Look for vague claims, redundant content, or generic language. If the results are delivered with extreme confidence with oddly precise numbers, it could be a red flag.
• Visit references: If an article or quote is cited, visit the referenced site personally to see if it exists.

How to Mitigate AI Hallucinations

Mitigating AI hallucination involves technical strategies, human oversight, and enhanced system design.

Technical Strategies to Reduce AI Hallucinations

1. Grounding in Reliable Sources

• Involving RAG: It is known as the retrieval-augmented generation approach, used in LLM and NLP. Using this, the machine’s output can be optimized to utilize a retrieval system that refers to an authoritative knowledge data source before producing the result.
• Using APIs: Build external APIs that can query verified external resources or any domain-specific resource in real-time and generate results.
• Guardrails: Building safeguards and including refusal mechanisms when the model is unsure about the context. It can validate the output of the machine and make corrections.

2. Fine-Tuning with Quality Data

• We need to train and then fine-tune the model with an extensive amount of data. Fine-tuning the LLM model can enhance the machine’s performance.

3. Prompt Engineering

• Use properly crafted prompts to enable the model to interpret and understand them, generating factual results.

Human Oversight Can Decrease AI Hallucinations

1.    Fact-Checking

• Keep humans in the loop for manually verifying the results generated by an AI model. This can help reduce any false information, which is highly critical in domains such as medical, legal, and financial.

2. User Feedback Loops

• Designing the model to get feedback from the users in terms of emojis, suggestions, comparison between two responses, etc.
• Use reinforcement learning with human feedback (RLHF) to improve truthfulness.

System Design Best Practices to Mitigate AI Hallucinations

1.     Audit Trails

• Transparency is key; all significant steps taken to design the model, including all sources and references, should be documented. This ensures compliance and accountability.

2. Confidence Indicators

• Show confidence scores or highlight potentially uncertain outputs to users. A confidence indicator is generally a score that indicates how specific the AI is of the result it has produced, based on which the user can decide whether to rely on or deny it.

3.     Regular Evaluation

• Continuously evaluate the model using hallucination tests on various datasets.

4.     Use Domain-Specific Models

• Smaller, domain-specific models trained on exclusive data that is authorized can perform well in terms of accuracy.

Conclusion

Fluency cannot be equated with accuracy. As powerful as these tools are, we still require human intervention to maintain their credibility and reliability. The next time you encounter an AI hallucination, be sure to fact-check and appreciate the intriguing complexity of machine-generated imagination.

References

Why IT needs a framework for responsible agentic AI – The Economic Times

Reducing hallucinations in large language models with custom intervention using Amazon Bedrock Agents | Artificial Intelligence and Machine Learning