Insightful stories that revolve around technology, culture, and design

In a multilingual digital world, keeping your website content translated, consistent, and fresh can be a challenge. 

That’s where Drupal’s AI-powered translation modules come in. 

With the rise of Large Language Models (LLMs), Drupal developers now have access to powerful tools that make content translation faster and easier.

Two key modules that streamline AI-based translation in Drupal are:

• AI Translate – Ideal for quick, inline, single-node translations using AI.
• AI TMGMT – Suited for bulk, workflow-based translation jobs with AI integration.

Let’s explore both:

AI translate module

The AI Translate module is part of the AI module suite and integrates directly with Drupal’s content translation system, which allows content editors to generate translations for nodes using AI providers (like OpenAI or others) with a single click.

Key features:

• One-click AI translation from the node “Translate” tab.
• Language-specific prompt configuration for better quality output.
• Automatically generates and saves translated content.
• Requires AI Core + AI provider (e.g., OpenAI).
• Uses Drupal’s core Content Translation module.

Configuration

Prerequisites:

• Configure Drupal content translation modules.
• Enable and set up api key for any AI provider

Enable modules: 

• AI Core
• AI Translate
• Any AI providers(eg., OpenAI)

Steps:

• Navigate to admin/config/ai/settings
• Under Translate Text, choose the Default Provider and Default Model

• Navigate to admin/config/ai/ai-translate
• Enable Use AI Translate as the default to translate content
• In Translate to {{language}} choose a provider model(provider_model) for AI model used for translating to {{language}} 
• Edit the Translation prompt for translating to {{language}} if required, or use the default prompt. You can refer to the Prompt suggested by the module maintainers for customising the prompts.
• Do the same for all the languages that require AI translation.
• Under Entity reference translation, choose the entity for translation(eg., Taxonomy term, Paragraph)
• Save configurations.

‍

• Edit any of your content and go to the Translate tab to find a new column, AI Translations. Here you can find Translate using {{provider_model}} against each language that does not have a translation for that content.
• Click on Translate using {{provider_model}} and a batch process will run to translate the content. 

• Once done, you will get the translated content.

AI TMGMT Module

The AI TMGMT (Translation Management) module serves as an AI-based translator plugin for the Translation Management Tool (TMGMT) project. It leverages the AI module to support a wide range of providers, including OpenAI, Ollama, and other paid or free/local options. This ensures you can always access the latest, most cost-effective models for accurate and automated content translation.

Key Features:

• Quickly translate content using AI, with the flexibility to customize translation style.
• Seamlessly integrates with the AI Translate sub-module, enabling language-specific model selection and prompt customisation.
• Translate one or multiple content items effortlessly with just a few clicks.
• Leverage a powerful translation job management interface to submit, track, and review AI-generated translations.
• Fully supports all the robust features offered by the TMGMT module,such as a detailed review workflow, support for various content sources, and more.

Configuration‍

Enable Modules: 

• Translation Management Core
• AI Translator
• Content Entity Source

Steps: 

Once enabled, the module provides the Translation menu item in the navigation.

• Navigate to admin/tmgmt/translators - Providers
• Here you can see the Drupal AI provider. Click on Edit to connect the AI provider.
• Give a proper label and description for the provider. (available by default)
• Enable Auto accept finished translations if you want to skip the reviewing process and automatically accept all translations as soon as they are returned by the translation provider.
• Choose the Provider plugin as AI
• In AI plugin settings under Translation configuration, choose Use the configuration from the "AI Translate" module to use the configuration from the AI Translate module. 
• Choose Use the configuration from this module in case you want to use the configuration from the module.
• Select the Tokeniser counting model and Chat translator model
• Click on Connect.
• If you get successfully connected! message: The AI provider is connected properly. Otherwise, check if your AI API key is valid and try again.
• Check if the Remote language mappings are proper and save the form.
• Once this is done, you can use the tmgmt module as it is, and the translation will work using the AI provider.

• Now navigate to the admin/tmgmt/sources to view the content overview 
• Here you can choose the content source as content to view all the content available in the website. Same in case of other content entities.

Now you are allowed to select multiple items from the list to translate together. You can see the title, columns for each language. Against each content, there are symbols under each language. The home symbol indicates original translation, the cross symbol represents no translation available for that language, and the green check implies there is translation available for that particular language. 

• So now you can select multiple contents to be translated
• Choose the source language and Target language to translate
• Click on Request translation

• Once done, you land on the source page with yellow triangle icons against content you tried to translate. This indicates you need to review the translations and save them.

• Click on the yellow triangle to navigate to the review page.
• Review each translated field content and approve it by clicking the check buttons.

• Once done, click on Save as completed.
• Once saved, you land again on the source page and find that the yellow triangle against the content has changed to a green tick, indicating the translation is saved and available. 
• Do the same for other content as well. 

You can view the translation status of each content in the job items page and the status of each group of translation in the jobs page.

From here, you can manage or review the translations and complete them as appropriate.

If you want to avoid the process of review of translations, you can enable the Auto accept finished translations field in admin/tmgmt/translators/manage/ai?destination=/admin/tmgmt/translators

Conclusion

Drupal’s AI-powered translation modules, AI Translate and AI TMGMT, bring speed, flexibility, and scalability to multilingual content workflows. Whether you’re translating a single node on the fly or managing complex, large-scale translation jobs, these tools empower site editors and administrators to harness the capabilities of modern AI models like OpenAI, Ollama, and more.

• Use AI Translate when you need quick, inline translations directly from the content interface.
• Use AI TMGMT when your workflow requires batch translation, review processes, and detailed management of translation jobs.

By integrating AI seamlessly into Drupal’s translation ecosystem, these modules help reduce manual effort, improve consistency, and deliver translated content faster without sacrificing editorial control. 

As LLMs evolve, these tools will continue to grow, offering even more efficient and intelligent ways to manage multilingual experiences in Drupal.

Reference‍

https://www.drupal.org/project/ai_tmgmt

https://www.drupal.org/project/ai 

https://project.pages.drupalcode.org/ai/1.1.x/modules/ai_translate/ 

‍

‍

In 2023, the U.S. the Department of Veterans Affairs used AI to process healthcare claims faster, reducing the time from 14 days to under 3 by automating triage and prioritization and thisshift translated into faster reimbursements, better patient service, and significant operational savings. 

Businesses across industries are investing in AI to solve real problems, like streamlining operations, reducing overhead, improving customer experience, speeding up the internal decision-making, enhancing compliance workflows, and reducing risk.

From logistics companies optimising delivery routes to banks using AI for fraud detection, the applications are increasingly core to how businesses operate. 

But here’s the catch: while the hype around AI is loud, clear conversations about its return on investment (ROI) are rare.

That’s why this blog exists: you’ll discover how to calculate the ROI of AI services, which metrics matter, what costs are often missed, and how to turn smart planning into real business outcomes.

If you're contemplating AI but unsure what it means for your bottom line, you're in the right place. When AI services are pitched, discussions often focus on capabilities. But when it comes to investing, the key question is simple: how much does it return?

How to calculate the ROI of AI services

‍

To calculate, the standard formula for return on investment is: ROI = (Net Benefits - Costs) / Costs.

But making this formula useful means being precise about what goes into each side of the equation.

On the benefit side, you account for time savings, accuracy gains, speed of operations, and downstream revenue. These benefits typically come from reducing manual workloads, improving forecasting and personalisation, and speeding up responses.

When it comes to the costs, it's not just about subscription or license fees. You should also factor in the cost of customising models, integrating them into your existing systems, preparing your data, and training your teams. Ongoing costs also matter, such as system maintenance, periodic retraining, and scaling infrastructure.

According to a 2023 McKinsey study, 44% of companies implementing AI underestimated the costs associated with data infrastructure and training. These overlooked costs can often significantly affect the difference between projected ROI and actual performance.

Key ROI metrics for AI services

Time saved per task

This is often the easiest and simplest metric to measure. When AI takes over tasks like document classification, ticket triage, or invoice handling, each transaction takes less time. 

For instance, if your finance team processes 10,000 invoices a month and automation saves 10 minutes per invoice, you save 100,000 minutes, about 1,667 hours. At an average cost of $30/hour, that equals roughly $50,000 per month.

Operational efficiency

AI can reduce delays, improve routing, and eliminate bottlenecks. 

Uber Freight has leveraged AI-powered optimisation to cut down empty miles and improve truck utilisation across its network. By analysing traffic, weather, and load data in real time, the company significantly cut route inefficiencies, boosting delivery reliability and reducing operating costs. 

Efficiency metrics often show up in throughput: the number of support tickets resolved, orders processed, or inquiries answered within a given time. Measuring before and after deployment helps isolate the value.

Error reduction

AI reduces human error in repetitive or decision-heavy tasks. Whether it’s data entry, demand forecasting, or product categorisation, accuracy gains can prevent costly mistakes.

A B2B SaaS company deploying an AI triage system for customer tickets saw a 22% drop in SLA violations, reducing the number of escalations and saving team bandwidth, according to this case study summary.

Revenue attribution

AI doesn’t just cut costs, it can also drive top-line growth. Personalised product recommendations, churn prediction models, and dynamic pricing engines can all increase revenue.

Revenue ROI often shows up in increased customer lifetime value, improved conversion rates, or higher average order values. These require controlled testing to isolate results.

System performance

You should also track precision, recall, and latency. These technical indicators affect how reliably a system operates and how users respond to it. Low precision leads to irrelevant results, while long latency can frustrate users.

High-performing systems contribute to adoption and usage. For guidance on evaluation, see our AI testing guide.

Ramp-up time

Some AI systems deliver immediate benefits; others require a learning period. Consider how long it takes to get a model trained, deployed, and effective. The same goes for how long it takes your team to learn and adopt it.

Tracking ramp-up time is key to understanding when returns start and how long the payback period might be.

Factors to consider before investing in AI

Business value alignment

Start with a problem that affects the bottom line. AI should not be used for experimentation alone. Instead, it should improve processes that matter: reducing cost, increasing revenue, or improving speed.

If your support volume is rising and your ticket backlog is increasing, that’s a clear cost centre. A properly tuned AI assistant might bring measurable improvement here within one quarter.

Data quality

Many AI projects don’t work because of poor input data. Unstructured, inconsistent, or incomplete data limits what AI can do.

Conducting a data readiness audit early can prevent delays and budget overruns later. This includes checking data volume, structure, labelling, and relevance to the task.

Integration needs

Your current tech stack plays a major role. Some AI tools offer plug-and-play connectors; others require API customisation or infrastructure changes.

For organisations running on platforms like Drupal, see how we've approached AI in Drupal implementations.

Long-term ownership

Even after launch, AI systems require monitoring and maintenance. Over time, models may drift, and new edge cases may emerge. Retraining, compliance updates, and UI/UX changes must be factored into total cost of ownership.

After an AI system is launched, it still needs to be monitored and maintained. Over time, models can change, and new edge cases may emerge. When figuring out the total cost of ownership, consider retraining, compliance updates, and UI/UX updates.

Skills and resourcing

Determine whether your internal team can handle the system maintenance or whether vendor support is required. Long-term success is rooted in shared ownership. Our approach to AI services supports capability-building alongside deployment.

Where AI ROI is highest in B2B

AI is proving to be a game-changer in B2B, especially in areas that require frequent decision-making. In sales, for example, AI can help prioritise leads, suggest follow-ups, and customise email outreach.

HubSpot has found that teams leveraging AI can cut their sales cycles by as much as 12%.

In the realm of customer support, AI tools for ticket triage and classification can significantly speed up response times and decrease the number of tickets agents need to manage. One global SaaS company reported a 15% reduction in support staff needs thanks to AI, saving them $1.3 million each year.

When it comes to procurement, AI assists with inventory planning and forecasting suppliers. Gartner estimates that AI can help reduce inventory costs by up to 10% while still maintaining high service levels.

For more information, explore our AI workflow assistant solutions.

Benefits and tradeoffs of AI systems

AI brings real advantages, but some tradeoffs are involved.

Benefits

AI systems improve throughput, reduce delays, and surface insights. They operate 24/7 and can be scaled without scaling costs. Personalisation features improve experience and retention.

Tradeoffs

Successful AI adoption requires structured data, systems integration, and training. Predictive systems typically take longer to show ROI than automation systems. Ongoing oversight is also necessary.

Well-scoped implementations help reduce effort. Read our blog on how AIaaS has changed.

Why do some organisations proceed cautiously?

Many companies proceed carefully, often based on past experience or internal constraints.

Some have tried AI projects that overpromised and underdelivered. Others encounter gaps in their data after implementation begins. Internal teams may worry about automation changing workflows or roles.

Compliance requirements can also shape the scope. Finance and healthcare teams need transparent systems that meet audit and reporting standards.

These factors don’t prevent AI projects. They shape planning. Teams that invest time in audits, change management, and compliance reviews tend to execute more successfully.

Hidden value of AI services

There are indirect benefits to AI that are just as real, even if they’re harder to model.

Faster decision-making has compounding value. When you reduce time-to-insight from days to minutes, business leaders can respond more quickly to shifts in the market.

AI also improves morale by taking repetitive work off people’s plates. Employees prefer working on tasks that use judgment, not repetition. This reduces turnover and speeds up onboarding.

Organisations that invest in AI also test and learn faster. They can try more campaigns, pricing experiments, or support approaches in less time.

AI-powered fraud and risk detection systems identify issues earlier. And perceived innovation helps with brand equity. Companies that show AI capability attract more talent, partners, and attention.

Soft ROI: people-first outcomes

Not all returns show up on a balance sheet. AI frees teams from repetitive work, improves morale, and reduces churn. That’s time and energy reallocated to strategic, creative, or client-facing work.

At QED42, we’ve seen this through AI workflow assistants that cut ticket backlogs, and in platforms like the UNICEF Learning Cabinet, where faster access to insights helps teams focus on outcomes that matter.

With Aeldris, we’re helping legal aid staff spend less time triaging cases and more time with the clients who need them. That shift in attention has operational and emotional payoff.

Soft ROI improves how teams collaborate, how quickly they ramp up, and how well they serve users. It’s a long-term return worth tracking.

What to include when calculating ROI

To build an accurate ROI model:

• Include full system costs: setup, training, infrastructure, and updates
• Focus on outcomes: cost reduction, revenue gains, error reductions
• Run pilots before scaling: test against KPIs in a controlled environment
• Link system outputs to business impact: connect response times or accuracy to customer satisfaction or operational savings.
  

Conclusion

AI ROI is being benchmarked, audited, and tied directly to operations. According to PwC, AI could contribute up to $15.7 trillion to the global economy by 2030, with $6.6 trillion coming from increased productivity. The leading adopters are countries like the United States, China, the United Kingdom, and Germany, where AI is already integrated into sectors such as healthcare, banking, logistics, and public infrastructure. 

In the Middle East, governments are investing billions in national AI strategies, including Saudi Arabia’s $40 billion AI investment plan. In India, AI spending across industries such as pharma, finance, and government grew by more than 30 per cent in 2023, according to IDC.

Across industries, AI is embedded in high-impact use cases. Mastercard uses AI to detect fraud in real time. Pfizer accelerates drug discovery with AI. Walmart uses it to forecast demand and optimise inventory. Salesforce has embedded AI into its core CRM to reduce support costs and improve customer experience.

What’s changing is how ROI is tracked. Companies are moving past vanity metrics like total queries or automation rates. They are reporting on time saved per task, reduction in SLA violations, increases in accuracy, operational savings, and revenue impact. In 2024, McKinsey found that leading companies are 3.5 times more likely to measure AI performance using business KPIs, not just technical ones.

The future of AI ROI will be clearer and more connected to real business results. Some Fortune 500 companies are already including AI performance in shareholder updates and quarterly reports. AI is becoming a core part of operations, monitored regularly and expected to deliver consistent outcomes.

No hype, just performance. For practical implementation, see how QED42 approaches AI services.

Frequently asked questions

Why is ROI measurement important?
It removes guesswork and enables confident decisions. Without tracking ROI, it’s difficult to justify continued investment or recognise what works.

What metrics are most useful?Prioritise metrics linked to business outcomes: hours saved, errors reduced, response time improvements, and revenue lift. Precision and accuracy matter, but only in service of those goals.

What challenges affect ROI?The most common ones are weak data pipelines, unclear objectives, and overlooked support costs. Building in early evaluation steps helps reduce risk and clarify expected returns.

‍

‍

We always wanted machines that could think. What we got instead were machines that listen. Not perfectly, not like us, but close enough to change everything.

The strange part is how quickly it stopped feeling strange. One year you're typing into a search bar, trying to guess the right keywords. Next, you're in a live conversation with something that doesn’t sleep, doesn’t blink, and doesn’t forget. And it's not just ChatGPT or Claude or Gemini. It's your documents, your calendar, your inbox, your codebase, your CRM. The conversation is happening across all of it. Quiet, constant, and invisible.

People call it agentic AI. It sounds like branding. What it really means is that the machine doesn’t wait for instructions. It takes a prompt and moves. Refund the item. Notify the customer. Update the CRM. Adjust the inventory. Schedule the follow-up. No buttons. No workflow triggers. Just finished tasks, one after another, like falling dominoes. And when something breaks, the AI adjusts. Not always perfectly, but often enough to feel real.

This isn't automation. It's delegation. That’s the shift. And once you see it, it’s hard to unsee.

This is the new AIaaS. Less about models and more about momentum. Built not just to reply, but to carry work from start to finish. Let's read more about it.

AIaaS: how businesses adopt AI without starting from zero

AIaaS lets organisations use artificial intelligence without building everything from the ground up. Instead of training custom models or managing infrastructure, teams can access ready-made tools from platforms like AWS, Google Cloud, Azure, and IBM Watson. These tools offer machine learning, language processing, document analysis, and fraud detection through APIs or simple interfaces.

This approach is already changing how different sectors work. A finance team can flag suspicious transactions using a pre-trained model. Legal departments can sort documents by case type automatically. Healthcare providers can manage appointments using a conversational assistant. These services fit into existing systems without requiring major development or investment.

The real benefit is simplicity. There’s no need to set up infrastructure, wait through long implementation cycles, or build in-house AI expertise. AIaaS is designed to get results quickly, letting teams focus on outcomes instead of the technology behind them.

‍

Types of AI as a service

AI is moving from simple automation; the companies making real progress are investing in solutions that match how they already work.

Retrieval-Augmented Generation (RAG) is one of the most used approaches. It helps AI deliver accurate responses by extracting data from trusted sources.

• Static RAG uses internal content for consistency
  
• Dynamic RAG pulls from live external sources
  
• The hybrid RAG does both, switching based on the task, and can be further enhanced by integrating knowledge graphs with RAG for deeper context and accuracy.
  This setup supports legal helpdesks, customer portals, and internal tools where accuracy is critical.

Agentic architecture allows different AI agents to plan, act, and verify results in sequence. These modular setups are ideal for workflows that require reasoning, validation, or escalation. Aeldris is an example of a platform that supports this kind of structure.

Multi-Channel Processors (MCPs) let systems receive input through voice, chat, or forms. They support flexibility in how users interact with AI, especially in customer-facing or multilingual environments.

Agent-to-Agent (A2A) communication allows agents to pass tasks to each other. This keeps workflows going without resets, especially in long or multi-step processes.

Voice and text assistants are the layer most users see. These assistants do more than chat; they book appointments, file requests, summarise documents, and complete domain-specific tasks using the logic and data behind the scenes.

Model training and fine-tuning come into play when prebuilt models do not meet the mark. Customising models like LLaMA AGASensures they align with business data, languages, or workflows.

Business consulting for AI integration helps organisations choose the right use cases, map AI to real decision points, and measure impact across speed, accuracy, or cost.

They are working systems already in use, already solving real business problems. The shift is underway. And this is what it looks like.

Why prediction is no longer enough

Most current AI services are reactive. They classify, complete, and summarise while working well for static, one-shot tasks.

But what about:

• Filing an insurance claim that requires multiple checks and steps?
  
• Drafting a legal response that draws from three different databases?
  
• Guiding a user through a health decision based on changing symptoms?
  

In these scenarios, prediction, only systems break down. They lack memory, can’t adapt, and don’t understand what the task is.

To solve this, AIaaS is evolving into agentic infrastructure: systems that plan, use tools, track progress, and adjust when the unexpected happens.

What reasoning agents do differently

Reasoning agents are designed to complete tasks with structure, logic, and memory. Instead of giving a one-time answer, they move through a process step by step, using context and available tools. 

Tracking progress

Agents keep track of what’s done and what comes next. This structured reasoning uses internal memory or "scratchpads," like in GPT-4o on ChatGPT and Claude, allowing them to handle complex, multi-turn tasks more reliably.

Evaluating how well RAG systems perform is becoming critical; frameworks like Ragas help measure contextual accuracy, relevance, and completeness.

Using tools mid-task

They don’t rely only on what they’ve seen. Through APIs, databases, and live search, agents can act while working. ChatGPT’s function calling and Perplexity’s web access are strong examples of this in action.

Making decisions step by step‍

Reasoning agents don’t rush to an answer. They pause, check, and respond based on what’s already known. This is key in areas like onboarding, finance approvals, and legal reviews, where each step depends on the last.

Adapting to change

If something shifts mid-process, agents can adjust. Platforms like Gemini and Claude support longer interactions that allow reasoning across changing inputs.

Reasoning agents work through tasks, with memory, tools, and logic. In AIaaS, this is not a bonus feature. It’s what makes systems reliable, usable, and ready for real business impact.

Why this shift matters beyond the backend

In 2024, a Capgemini survey of 12,000 consumers found that 58% use GenAI tools like ChatGPT, Gemini, and Perplexity for product and service recommendations, up from just 25% the year before.

During the same year’s holiday season, Adobe Analytics reported a 1,300% increase in AI-powered search referrals to U.S. retail sites.

These users are leading indicators of where digital behaviour is heading. They tend to be younger, higher-income, and more engaged, and their journeys now often begin inside a conversation with an LLM:

“What’s the best coffee machine under $200?”
“Plan a weekend trip that’s quiet and close to nature.”

These agents aren’t just model endpoints. They’re becoming decision-making interfaces, and that means your AIaaS strategy now shapes both how internal systems operate and how customers interact with your brand from the very first question.

The rise of SOM: what LLMs think about your brand

To track this new dynamic, marketers and researchers have coined a new metric: Share of Model (SOM).

SOM measures how often and how favourably LLMs recommend your brand, based on real user prompts.

Unlike traditional metrics like Share of Voice (SOV) or Share of Search (SOS), SOM is a model-facing. It reflects what LLMs reason through when they try to solve a user's task.

Jellyfish’s Share of Model (SOM) platform tested prompts across ChatGPT, Gemini, Perplexity, and others, revealing striking differences in how LLMs surface brands.

• Ariel (laundry care) had a 24% SOM on Llama, but less than 1% on Gemini.
  
• Chanteclair appeared prominently on Perplexity but was absent from Meta’s LLM.
  
• Lincoln showed strong human brand recall, but did not surface in most LLM responses, likely because its messaging emphasises aspirational qualities, while LLMs prioritise functional relevance and task resolution.
  

These differences highlight a key shift: LLMs don’t simply index popularity; they select what helps resolve a prompt. That means brands must think beyond attention and start optimising for AI reasoning paths.

LLMs don’t index. They decide. And if your brand doesn't help them resolve a task, you won't be recommended.

LLMs as agents: where AIaaS and brand discovery meet

Here’s the connection: the LLMs behind ChatGPT, Gemini, and Perplexity are fully realised AIaaS platforms.

They work through a few key parts:

• How they understand and respond
  
• How do they use tools?
  
• How do they remember things?
  
• How they learn and improve
  

These systems are built to reason across context, trigger external actions, and respond to evolving intent. They function as thinking agents, capable of handling multi-step workflows and decision paths.

This highlights what AIaaS now supports: not just predictions, but agents that complete real tasks. Whether they’re guiding a customer to a product or powering internal operations, these agents now sit at the centre of how businesses interact, respond, and deliver outcomes.

Benefits and challenges of AIaas 

Instead of building everything from scratch, companies access powerful models and agents through cloud platforms. They connect via APIs, pay as they go, and get instant access to the latest improvements without managing the infrastructure.

The benefits are clear:

• Speed: What once took months to build can now be tested and launched in weeks.
  
• Flexibility: AI tools can be added to workflows for search, support, automation, or content generation. Real-world implementations like QED42’s machine learning layer on Slack show how AIaaS enhances team communication and internal workflows.
  
• Cost savings: No need for large internal AI teams or heavy infrastructure.
  
• Scalability: Services like OpenAI, Google Cloud AI, AWS AI Services, and Azure AI offer powerful, production-ready capabilities.
  
• Advanced features: Many platforms now support tool use, memory, and step-by-step reasoning, making it possible to build agents that do more than answer; they complete tasks with context.
  

But AIaaS also comes with real challenges:

• Customisation limits: Out-of-the-box tools often fall short in domain-specific tasks.
  
• Integration issues: Legacy systems, inconsistent data, and unique workflows still require engineering effort.
  
• Privacy and compliance: With sensitive data flowing through third-party services, concerns around GDPR and local data laws are rising. See OECD’s AI risk report.
  
• Vendor lock-in: Once a company builds around a provider, switching can be difficult and expensive.
  
• Security and oversight: As agents take on more responsibility, the need for transparency, explainability, and monitoring grows. Read more from NIST’s AI risk framework.
  

AIaaS has opened the door for faster, smarter development. But scaling it responsibly means going beyond easy wins. 

Conclusion

A lot of the focus in AI used to be on speed. How fast a model could respond, how cheap it was to run, and how well it could be tuned to answer a question. And sure, that still matters. But what matters more now is what AI actually does. Not just replying, but doing. Slowly, we’re moving toward systems that take initiative.

These agents remember what happened earlier. They plan the next steps. They connect to APIs, trigger CRM workflows, and adapt when something changes. And this isn’t theory anymore. It’s already showing up in production. Platforms like Aeldris are helping companies bring agents into finance approvals, legal work, and internal operations.

Governments in Singapore and the UAE are building agent-driven systems for healthcare and public services. South Korea is putting national investment behind reasoning-based AI programs. Amazon and Shopify are using agents to run support, logistics, and storefronts. Stripe uses agents to power customer service. IKEA is using them behind the scenes to make operations smoother.

‍

‍

A year ago, AIaaS was about responding faster and cutting costs. Now it is about giving systems memory, reasoning, feedback, and the ability to actually carry things out.

The global shift toward cloud and AIaaS increased fast after 2020, as covered in QED42’s piece on post-COVID cloud adoption. That shift laid the groundwork for everything we're seeing now.

In my view, this is one of the most important changes in how we interact with technology. We are not just building smarter tools. We are starting to build systems that work alongside us. That raises new questions about trust and accountability. But it also opens up real opportunities to rethink how work gets done and who does it.

We’re seeing agents that specialise in legal, finance, and business tasks. Agents that work together, passing tasks between them. Agents that reflect a brand’s voice and decision-making style. And a new kind of digital presence, where being inside the model could matter as much as ranking in Google search.

The big question isn’t just what the model can say.
It’s what the agent can figure out and actually do.
And that, to me, is where things start to get interesting

Frequently asked questions

What is AI as a Service (AIaaS)?
AIaaS is a way for businesses to use advanced AI tools without building everything themselves. It offers features like chatbots, language understanding, and image analysis through cloud platforms. You can access these tools through APIs and start using them quickly.

How is AI as a Service (AIaaS) different from SaaS?
SaaS gives you complete software, like email or project management tools. AIaaS gives you specific AI abilities that you can add to your systems. It focuses on things like understanding text, making predictions, or automating tasks.

What are some of the best AI as a Service (AIaaS) platforms?
The most popular platforms in 2025 are OpenAI, Google Cloud Vertex AI, Microsoft Azure AI, AWS Bedrock, and Anthropic. They offer powerful models, easy-to-use tools, and the flexibility to build smart features into your existing workflows.

‍

AI in Drupal has come a long way in a short time. With version 1.1 of the AI Agents module, it's now much simpler to create your AI agents right from the admin interface. No coding is needed, and setup is quick.

These agents can do more than just chat. They can help users find content, assist with form submissions, or support your editorial team with routine tasks.

For example, you could build an agent that guides visitors through your blog, finds related articles, and summarises content so readers get the main points faster.

In this blog, we’ll walk through how to create your own AI agents in Drupal and show what they can do to make your site more helpful and efficient.

Install modules and configure your AI provider

First, you'll need to install and enable the required modules, which are

• AI Agents
• AI Agents Explorer
• AI API Explorer
• AI Provider OpenAI (Or any other provider that supports Tool calling)

Next, you'll need to set up the AI Provider OpenAI module. The best place to find the latest instructions for this is on the module's project page.

‍

Finally, navigate to Configuration -> AI -> AI Default Settings. Here, you need to select a model for the ‘Chat with Tools/Function Calling’ operation.

Creating our first AI Agent

• Go to Configuration -> AI -> AI Agents Settings
• Click on ‘Add AI Agent’

‍

We'll begin with a simple agent designed to suggest five taxonomy terms for any given topic. To set this up, you just need to add the following details:

• Label: Taxonomy term generator
• Description: This agent suggests 5 taxonomy terms for a given topic.
• Swarm orchestration agent / Project manager agent: Leave both of these options unchecked for now.
• Max loops: Change this to 1.

Now for the most important part: the instructions. Under the Usage details section, paste the following prompt into the Agent instructions field.

“You are a smart AI assistant integrated with a  Drupal website. Suggest 5 taxonomy terms that are specific instances or subtypes of the given topic. Prioritise concrete examples commonly used for categorisation, not abstract concepts or related fields. Return ONLY comma-separated terms (no explanations, numbering, or extra text).”

Once you're done, click Save.

To see our new agent in action, go back to the agent settings page (config/ai/agents) and click the Explore link next to your "Taxonomy term generator" agent. (Note: this link will only be visible if you have the AI Agents Explorer module installed).

In the explorer interface, type any topic into the prompt field and click Run agent. You'll see the output appear in the Progress section.

‍

Congratulations! You've just built your first AI Agent!

Tools: the infinity stones of Agents

Tools are what give agents their real power. They are specific functions that help an agent perform actions beyond just generating text. A tool can be:

• Another AI agent (known as a sub-agent)
• A Drupal Core Action
• An AIFunctionCall Plugin (allowing you to write custom tools with code)

Let's see how an AI agent can use tools. The AI Agents module provides a built-in tool named Modify taxonomy term, which can be used to create or edit taxonomy terms. We're going to update our "Taxonomy term generator" agent to use this tool, automatically saving the suggested terms into our "Tags" vocabulary.

But first, let's test the tool on its own. Edit the "Taxonomy term generator" agent you just created, find the "Modify Vocabulary" tool in the list and click the Test this tool option. You'll need to have the AI API Explorer module enabled to see this option.

‍

The tool requires several arguments, like vid, tid, and name. Let's give it a try:

• For vid, enter tags.
• For name, enter Earth.
• Click Run Function.

You should see a message like, "The term Earth was successfully created/edited," and you'll find the new term in your "Tags" vocabulary.

If you were to look at the source code for this tool, you'd see it's just a standard function for creating a taxonomy term. There's no "AI" inside the tool itself. The magic is that our agent can figure out how to call this tool with the correct arguments. The tool does the work and returns a success or error message back to the agent. That, in a nutshell, is how tool calling works

Adding the tool to our Agent

Replace the prompt of the ‘Taxonomy term generator’ agent with the following

“You are a smart AI assistant integrated with a  Drupal Website. Your task is to suggest 5 taxonomy terms that are specific instances or subtypes of the given topic. Prioritise concrete examples commonly used for categorisation, rather than abstract concepts or related domains. Once the terms are identified, use the modify_taxonomy_term tool to save them.”

Next, scroll down to the Tools section and select the Modify taxonomy terms tool. Once you select it, a new Detailed tool usage section will appear on the form. Expand the Property restrictions element to see the options.

This is where we can control the arguments passed to the tool. For example, our agent should add the taxonomy terms only to the ‘tags’ vocabulary. One way to enforce this is to add something like the following to the agent instructions.

"When using the modify_taxonomy_term tool, always use 'tags' as the value for the 'vid' parameter."

While this would probably work, a better and more reliable method is to enforce the value using the ‘Restrictions for property vid’ field. The default value for this section is ‘Allow all’. Change that to ‘Force value’ and enter ‘tags’ in the ‘values’ field.

If you select ‘Force value’, an additional checkbox, ‘Hide property’, will become available. This feature prevents the property from being sent to the LLM altogether, which is ideal for fields that store sensitive information like API keys.

‍

Now, save the agent and click the Explore button again to test our changes.

You'll probably see something interesting. The agent tries to call the tool, but the final response says ‘Not solvable’. And if you check your "Tags" vocabulary, you'll see the new terms haven't been created.

So what's going on? This happens because of the Max loops setting. Remember how we set it to 1 earlier? With a max loop of 1, the agent can only communicate with the LLM once. In that single step, the LLM decides which tool to use and what arguments to pass. But agent doesn't have a chance to actually run the tool and confirm the result. For that, it needs a second loop.

Go back and edit the agent, change Max loops to 2, save it, and try again. This time, it should work perfectly! The agent will use the tool, and the new terms will appear in your vocabulary.

Adding multiple tools

Let's try to improve the functionality of our taxonomy generator agent. Instead of adding all the terms to the "Tags" vocabulary, our agent should be able to create vocabularies that don't exist yet (like "Planets" or "Fruits") and then add terms to them. To do this, we'll need to give it a few more tools:

• List bundles: To check the currently available vocabulary names.
• List taxonomy term: To get the terms that already exist in a vocabulary (useful for preventing duplicates).
• Modify vocabularies: To create new vocabularies if they don't exist.
• Modify taxonomy term: The tool we used before to create or edit terms.

Update the prompt of our agent as follows

You are a taxonomy manager agent integrated into a Drupal 11 website. You help to provide information about existing vocabularies and terms, as well as adding new terms and vocabularies. You are a looping agent, meaning you can run multiple times till the task is completed.

You have the following tools available

1. list_bundles: Provides the information about currently existing vocabularies.

2. modify_vocabulary: Can be used to create new vocabularies.

3. list_taxonomy_term: Can give the existing terms present in a vocabulary

4. manage_taxonomy_term: Can be used to add new terms to a vocabulary/modify existing terms.

Before adding terms, make sure that the vocabulary exists. Also, make sure you do not add any existing terms to any vocabulary, unless explicitly requested by the user

Next, you'll need to configure the agent to use these new tools.

1. In the Tools section, select all four of the tools listed above.
2. Remove the hardcoded tag value from the ‘Detailed tool usage’ section that we set up earlier.
3. For the ‘List bundles’ tool, find the ‘Restrictions for property entity_type’ field and set taxonomy_term as the forced value. 
4. Finally, before saving, change the ‘Max loops’ value to 10. This gives the agent enough attempts to check for a vocabulary, create it if needed, and then add the terms.

Once you've saved the agent, test it again with a prompt like: Create a fruits vocabulary and add 4 terms.’

Our agent is now smart enough to use its full suite of tools to handle the entire request.

Default information tools

In our previous example, you might have noticed that our agent ran multiple times, perhaps 4 loops, just to create the "Fruits" vocabulary and add the terms. Each loop increases both the response time and token usage. One of the key tools our agent had to use was list_bundles, simply to get a list of existing vocabularies.

What if we could give the agent this information upfront, as part of its initial instructions? This is exactly what the Default Information Tools section is for. It lets you pre-load information for the agent, making it more efficient.

Let's try it out:

• First, edit your agent and uncheck the List bundles tool from the main Tools section. We no longer need the agent to decide to call it on its own.
• Next, scroll down to the Default Information Tools section and add the following YAML configuration:
  ‍

vocabularies:
  label: Vocabularies
  description: 'The existing Vocabularies on the system'
  tool: 'ai_agent:list_bundles'
  parameters:
    entity_type: taxonomy_term

‍

Now, save the agent and test it again with the prompt: Create a fruits vocabulary and add 4 fruits.

‍

If you run this after the vocabulary has already been created, you'll see a much faster response. The agent will likely tell you that the "Fruits" vocabulary already exists without ever explicitly calling the list_bundles tool.

This happens because the tool was invoked automatically in the background, and its output (the list of vocabularies) was sent to the LLM as part of the agent's initial context. The agent had the information it needed from the very beginning.

Create a chatbot for our Agent

Now let's build a chatbot that allows users to interact with our new taxonomy agent. The first thing you'll need to do is enable the AI Chatbot module.

To use a chatbot, first, an AI Assistant has to be created.

Step 1: Create the AI Assistant

1. Navigate to Configuration > AI > AI Assistants and click Add AI Assistant.
2. Give it the name: Taxonomy assistant.
3. For the Instructions, enter the following. This tells the assistant to simply pass the user's request directly to our agent.

Always delegate the task to the 'Taxonomy term generator' agent. Whatever response the agent provides, return it to the user. You are just a router — you do not perform any actions.

4. Under the Agents enabled section, select our Taxonomy term generator agent.
5. Click Save.

Step 2: Place the Chatbot Block

With our assistant ready, the final step is to place the chatbot block on the site.

1. Go to Structure > Block layout.
2. Select the Content region of the Olivero theme and click Place block.
3. Search for and place the AI DeepChat Chatbot block.
4. In the block configuration form, select your newly created Taxonomy assistant from the ‘AI Assistant’ dropdown.
5. Click the save block, and you're all set! You can now visit any page to interact with your agent.

And there you have it! In just a few steps, we went from a simple idea to a fully functional AI agent that can understand a request, use multiple tools to interact with our site, and even power a user-facing chatbot. If you've followed along, you've already mastered the core concepts. I encourage you to dive in and start experimenting. Don't be afraid to try different prompts, combine new tools, and see what you can create. You might be surprised at how easy it is to build an AI assistant that makes your Drupal site smarter and your workflow easier.

Wrapping Up

By now, you've seen how powerful and flexible AI Agents in Drupal can be. Starting with a simple term suggestion agent, we gradually added more functionality, allowing it to create vocabularies, avoid duplicates, and even respond through a chatbot.

What's exciting about this setup is how easy it is to extend. If you want to automate more content tasks, just add another agent. If you need smarter results, tweak the prompts. You are not locked into one use case, and you don’t need deep AI or coding knowledge to start seeing real results.

Everything you need is already in place. The interface is ready, the features are powerful, and the possibilities are wide open. So go ahead, explore and experiment. You might be surprised by how quickly you can build something truly useful.

If you get stuck or want to learn more, the Drupal community is always there to help.

‍

‍

This post is part of our AI CKEditor Integration series. If you haven’t read the previous blog on setting up the AI CKEditor module, we suggest starting there to understand the basics.

The built-in features like translation, tone adjustment, and text completion offer a strong starting point. But the real strength of the module comes from creating custom plugins that match your specific content workflows.

In this blog, we’ll walk through how to build those plugins. You’ll learn how to define custom behaviour, connect it with the editor interface, and shape AI assistance around your editorial needs.

Why create custom AI CKEditor plugins?

While the AI CKEditor module ships with a variety of powerful tools such as translation, tone change, and summarisation, there are many scenarios where teams need functionality tailored to their content workflows. This is where custom plugins shine.

Here are a few reasons you might want to build a custom plugin:

• Business-specific use cases: You may want to generate product descriptions in a specific format, suggest metadata, or summarise legal content with a custom tone, needs that generic tools don't fully support. Brands may need custom plugins that align with brand values and styles.
• Workflow automation: Automate repetitive editorial tasks like cleaning up input from clients, converting text to a brand-specific tone, or inserting dynamic content placeholders.
• Dynamic features: Some plugins can dynamically adjust based on user roles, entity types, or content fields, allowing a smarter integration between CKEditor and your Drupal backend.

Understanding the architecture

Custom AI CKEditor plugins work by:

1. Taking input (selected text, form fields, or nothing)
2. Processing that input through an AI model
3. Returning formatted HTML output
4. Allowing users to edit the result before inserting it into the editor

Setting up Your development environment

Create a custom module or use an existing one. Your plugin file should be placed in:
‍

src/Plugin/AiCKEditor/{YourPluginName}.php

Module structure
‍

/custom_module/ 
├── custom_module.info.yml
└── src/ 
└── Plugin/ 
└── AiCKEditor/
 └── ImproveClarity.php

Basic plugin structure

Every custom AI CKEditor plugin should extend the AiCKEditorPluginBase class. To make your plugin discoverable by Drupal, decorate the class with the #[AiCKEditor(...)] attribute, which provides metadata such as id, label, and description. This is essential for your plugin to appear in the AI Tools list within CKEditor.:
‍

<?php


namespace Drupal\my_custom_module\Plugin\AICKEditor;


use Drupal\ai_ckeditor\AiCKEditorPluginBase;
use Drupal\ai_ckeditor\Attribute\AiCKEditor;


/**
* Plugin to do something custom.
*/
#[AiCKEditor(
 id: 'custom_feature',
 label: new TranslatableMarkup('My Custom Feature'),
 description: new TranslatableMarkup('This is my custom feature for AI CKEditor.'),
)]
final class MyCustomFeatureCKEditor extends AiCKEditorPluginBase {


}

Key methods to implement

Configuration methods

1. buildConfigurationForm(): This method is responsible for rendering the configuration form users see when setting up the plugin.
   
   If your plugin requires no custom settings, and you’ve extended the base plugin class, you can safely skip this method. However, if your plugin needs to allow users to choose an AI provider or model, this is where you'll implement that logic.
   
   For example, let’s say your plugin uses the AIRequestCommand and you want to give users the ability to choose from available providers. Here's how you might set up a provider selection dropdown in the form:
   ‍

/**
  * {@inheritdoc}
  */
 public function buildConfigurationForm(array $form, FormStateInterface $form_state): array {
   $options = $this->aiProviderManager->getSimpleProviderModelOptions('chat');
   array_shift($options);
   array_splice($options, 0, 1);


   $form['provider'] = [
     '#type' => 'select',
     '#title' => $this->t('AI provider'),
     '#options' => $options,
     "#empty_option" => $this->t('-- Default from AI module (chat) --'),
     '#default_value' => $this->configuration['provider'] ?? $this->aiProviderManager->getSimpleDefaultProviderOptions('chat'),
     '#description' => $this->t('Select the AI provider to use.'),
   ];


   return $form;
 }

‍

2. submitConfigurationForm(): Handles saving configuration data.
3. defaultConfiguration(): Set up the default configuration before the initial setup is done.

User Interface Methods

1. buildCkEditorModalForm(): This method defines the form that end users interact with inside the CKEditor AI modal when they use the plugin.
   ‍

public function buildCkEditorModalForm(array $form, FormStateInterface $form_state, array $settings = []) {
 $storage = $form_state->getStorage();
 $selected_text = $storage['selected_text'] ?? '';
 $editor_id = $this->requestStack->getParentRequest()->get('editor_id');
 $form = parent::buildCkEditorModalForm($form, $form_state);


  // Your form elements here
  $form['response_text'] = [
   '#type' => 'text_format',
   '#title' => $this->t('AI Response'),
   '#prefix' => '<div id="ai-ckeditor-response">',
   '#suffix' => '</div>',
   '#allowed_formats' => [$editor_id],
   '#format' => $editor_id,
 ];
  return $form;
}

Processing methods

ajaxGenerate(): Handles the AI processing when users click "Generate".
‍

public function ajaxGenerate(array &$form, FormStateInterface $form_state) {
  $values = $form_state->getValues();
 
  try {
	$prompt = $this->buildPrompt($values);
	$response = new AjaxResponse();
	$response->addCommand(new AiRequestCommand(
  	$prompt,
  	$values["editor_id"],
  	$this->pluginDefinition['id'],
  	'ai-ckeditor-response'
	));
	return $response;
  }
  catch (\Exception $e) {
	// Handle errors appropriately
	$this->logger->error("Error in custom AI plugin: " . $e->getMessage());
	return $form['plugin_config']['response_text']['#value'] = "An error occurred.";
  }
}

Real-world example

Here is a plugin to improve the clarity of the selected text:
‍

 <?php


namespace Drupal\custom_module\Plugin\AICKEditor;


use Drupal\Core\Ajax\AjaxResponse;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\StringTranslation\TranslatableMarkup;
use Drupal\ai_ckeditor\AiCKEditorPluginBase;
use Drupal\ai_ckeditor\Attribute\AiCKEditor;
use Drupal\ai_ckeditor\Command\AiRequestCommand;


/**
* Plugin to improve the clarity of selected text.
*/
#[AiCKEditor(
 id: 'improve_clarity',
 label: new TranslatableMarkup('Improve Clarity'),
 description: new TranslatableMarkup('Rewrite selected text to improve readability and clarity.'),
)]
final class ImproveClarity extends AiCKEditorPluginBase {


 /**
  * {@inheritdoc}
  */
 public function defaultConfiguration(): array {
   return [
     'provider' => 'NULL',
   ];
 }


 /**
  * {@inheritdoc}
  */
 public function buildConfigurationForm(array $form, FormStateInterface $form_state): array {
   $options = $this->aiProviderManager->getSimpleProviderModelOptions('chat');
   array_shift($options);
   array_splice($options, 0, 1);


   $form['provider'] = [
     '#type' => 'select',
     '#title' => $this->t('AI provider'),
     '#options' => $options,
     "#empty_option" => $this->t('-- Default from AI module (chat) --'),
     '#default_value' => $this->configuration['provider'] ?? $this->aiProviderManager->getSimpleDefaultProviderOptions('chat'),
     '#description' => $this->t('Select the AI provider to use.'),
   ];


   return $form;
 }


 /**
  * {@inheritdoc}
  */
 public function submitConfigurationForm(array &$form, FormStateInterface $form_state): void {
   $this->configuration['provider'] = $form_state->getValue('provider');
 }


 /**
  * {@inheritdoc}
  */
 public function buildCkEditorModalForm(array $form, FormStateInterface $form_state, array $settings = []): array {
   $storage = $form_state->getStorage();
   $editor_id = $this->requestStack->getParentRequest()->get('editor_id');


   if (empty($storage['selected_text'])) {
     return ['#markup' => '<p>' . $this->t('Please select some text before improving clarity.') . '</p>'];
   }


   $form = parent::buildCkEditorModalForm($form, $form_state);


   $form['selected_text'] = [
     '#type' => 'textarea',
     '#title' => $this->t('Selected text'),
     '#default_value' => $storage['selected_text'],
     '#disabled' => TRUE,
   ];


   $form['actions']['generate']['#value'] = $this->t('Improve Clarity');


   return $form;
 }


 /**
  * {@inheritdoc}
  */
 public function ajaxGenerate(array &$form, FormStateInterface $form_state) {
   $values = $form_state->getValues();


   try {
     $prompt = 'Rewrite the following text to improve clarity and make it easier to understand without changing the meaning:' . PHP_EOL . '"' . $values["plugin_config"]["selected_text"] . '"';
     $response = new AjaxResponse();
     $response->addCommand(new AiRequestCommand($prompt, $values["editor_id"], $this->pluginDefinition['id'], 'ai-ckeditor-response'));
     return $response;
   }
   catch (\Exception $e) {
     $this->logger->error("There was an error in the Improve Clarity plugin: @message", ['@message' => $e->getMessage()]);
     return $form['plugin_config']['response_text']['#value'] = "An error occurred during AI processing.";
   }
 }
}

See your plugin in action

Once you've created your custom AI CKEditor plugin, enabling it follows the same process as the built-in plugins:

• Clear cache to ensure Drupal discovers your new plugin
• Navigate to Administration → Configuration → Content authoring → Text formats and editors
• Select and configure your text format (e.g., Full HTML → Configure)
• Find your custom plugin in the "AI tools" section under "CKEditor 5 plugin settings"

• Enable and configure your plugin as needed

‍

• Your custom plugin will now appear in the AI Tools dropdown when users click the ✨ button in CKEditor, ready to enhance content with your specialized AI functionality.

‍

‍

Conclusion

Creating custom AI CKEditor plugins gives you the flexibility to shape content workflows around real editorial needs. 

Whether it’s refining tone, automating structure, or guiding writers with contextual prompts, each plugin can bring meaningful improvements to the way content is created and managed.

Start with a clear use case, build in small steps, and adjust based on real feedback. 

Drupal’s plugin architecture, combined with the AI CKEditor module, provides a strong foundation for developing tools that feel native to your workflow and make everyday writing faster, more focused, and more consistent.

‍

Artificial intelligence is changing how content gets created, reviewed, and published, and Drupal is keeping up. 

The AI CKEditor Integration module brings the capabilities of large language models (LLMs) directly into the content editing experience. Instead of jumping between external tools or copying drafts back and forth, editors can now work smarter within the CKEditor interface itself.

From translating content to checking spelling and grammar, adjusting tone, and completing sentences, the module makes everyday tasks faster and more consistent. It supports editors in maintaining quality, staying on message, and saving time, right where content is written. 

By embedding AI features directly into CKEditor, this integration simplifies content workflows and gives teams the kind of intelligent assistance that keeps pace with modern publishing demands.

AI CKEditor integration module

The AI CKEditor Integration module is a powerful extension that seamlessly integrates AI capabilities into Drupal's CKEditor 5. 

AI CKEditor Integration is a submodule available in AI Core module that provides plugins that integrate with CKEditor 5. Rather than switching between different tools or applications, content creators can access AI-powered features directly within their text editor, streamlining the content creation process.

Prerequisites and dependencies

Before diving into the setup, ensure you have the following modules installed and configured:

1. AI Core Module: The foundation that handles AI interactions
2. AI Provider Module: Such as the OpenAI Provider, Ollama ,etc, which connects to your chosen AI service
3. CKEditor 5: Drupal's default rich text editor (included in Drupal core)

Installation and configuration

Step 1: Enable the Module

First, enable the AI CKEditor Integration module through Drupal's admin interface or using Drush:

drush en ai_ckeditor

Step 2: Configure text formats

1. Navigate to Administration → Configuration → Content authoring → Text formats and editors (/admin/config/content/formats)
2. Select the text format you want to enhance (e.g., "Basic HTML")
3. Click Configure next to your chosen format

Step 3: Add the AI tools button

1. In the CKEditor toolbar configuration, locate the AI Stars ✨ widget
2. Drag it from the "Available buttons" section to your "Active toolbar"
3. Position it where you want it to appear in the editor toolbar

Step 4: Configure AI tools

1. Scroll down to CKEditor 5 plugin settings
2. Find the AI tools section
3. Configure each available tool according to your needs:
   
   1. Enable or disable individual tools
   2. Select the appropriate AI model for each tool
   3. Set specific parameters for each feature

Special plugin configurations

Setting up the tone plugin

The Tone plugin requires a custom taxonomy to define available tones:

Step 1: Create a taxonomy vocabulary

• Go to Structure → Taxonomy (/admin/structure/taxonomy)
• Add a new vocabulary (For example, name it  "Tone of voice")

Step 2: Add tone terms

• Create terms for different tones: "Friendly", "Professional", "Casual", "ELI5 (Explain Like I'm 5)", "Academic", etc.
• Optionally, add detailed descriptions for each tone in the term's description field

Step 3: Configure the plugin

• In the CKEditor AI tools configuration, select the vocabulary created in step 1.
• Enable "Use term description for tone description" if you want to use the detailed descriptions

Setting Up the Translation Plugin

Similar to the Tone of Voice plugin, the Translation feature requires a taxonomy:

‍

1. Create a taxonomy vocabulary. For example, name it “Languages”
2. Add language terms: "Spanish", "French", "German", "Japanese", etc.
3. Configure the plugin to use your Languages vocabulary

‍

Let us see our AI-powered CKeditor in action

Once configured, using AI tools is straightforward:

1. Open your content editor (node add/edit form with CKEditor)
2. Select a field that uses CKEditor

1. Click the AI Assistant button (✨) in the toolbar
2. Choose your desired AI feature from the dropdown menu

1. Provide any prompt needed in the modal that appears

6. Click "Generate" to process your request

6. Review and edit the AI-generated content

8. Click "Save changes to editor" to insert the content into your document

Conclusion

The AI CKEditor Integration module marks a meaningful upgrade in how content is created and edited in Drupal. By embedding AI features directly into the CKEditor interface, it removes the need for context switching and makes capabilities like tone adjustment, grammar correction, translation, and text completion accessible to everyone: from site editors to content strategists.

This module works within Drupal’s existing editorial workflow, so teams don’t need to learn new tools or disrupt their publishing process. With a simple setup and thoughtful defaults, you can start improving content quality immediately.

Looking ahead, the potential for deeper AI integration is just beginning. From content summarization and image generation to accessibility checks and editorial analytics, future enhancements could transform CKEditor into a true intelligent assistant for web publishing. 

As the Drupal ecosystem continues to adopt AI-powered modules, this integration sets the foundation for a smarter, more efficient content creation experience, built right into your CMS.

‍

In today's digital landscape, Search Engine Optimisation (SEO) plays a vital role in ensuring online visibility. Whether you're a small business or a large enterprise, SEO directly influences how easily users can find your content. With AI (Artificial Intelligence) transforming industries, automating SEO processes in platforms like Drupal can significantly improve efficiency and results.

Drupal, a powerful content management system (CMS), offers flexibility and scalability for building websites. When paired with AI tools, Drupal can streamline and automate many aspects of SEO, making it easier for website owners and administrators to optimise their sites without requiring extensive manual intervention.

In this blog, we will explore how AI can be utilised to automate SEO in Drupal, as well as the tools and techniques that can help you achieve better search rankings.

Why automate SEO?

Before diving into the specifics of AI, it's important to understand why automating SEO is essential. SEO is a multifaceted and time-consuming process that requires constant attention. From keyword research to content optimisation, backlink management, and technical SEO, there’s a lot to manage. Here’s why automation is crucial:

1. Efficiency: SEO requires consistent effort. Automation saves time and ensures tasks are done correctly and on time.
   
2. Data-driven insights: AI can process vast amounts of data and deliver actionable insights that can inform your SEO strategy.
   
3. Consistency: AI tools provide consistency across your entire website. Once set up, they ensure that your content and technical SEO elements are always optimized without needing constant adjustments.
   
4. Stay competitive: Search engine algorithms are constantly evolving. AI can help keep you ahead of these changes by adapting your SEO strategy based on up-to-date trends.

Introducing the AI SEO Drupal module

The AI SEO module is a contributed Drupal module that leverages AI services (e.g., OpenAI) to automate and assist with SEO tasks. It’s part of the broader AI Core ecosystem and integrates with your content types to generate:

‍

• Meta titles and descriptions
• Alt text for images
• Keyword suggestions
• Semantic improvements

Whether you're publishing articles, landing pages, or product descriptions, this module can help ensure that your content meets SEO best practices without extra manual effort.

Key features of the AI SEO module

1. Content analysis & suggestions

When you edit content, AI SEO analyzes your text and suggests improvements like better keyword use, clearer headlines, or restructuring paragraphs for SEO effectiveness.

2. Meta tag generation

The module generates contextually relevant:

• Meta titles (to improve CTR on search engines)
• Meta descriptions (to summarise page content)

This helps editors focus on writing content while AI handles the technical SEO layers.

3. Image Alt text generation

AI reads your images (file names and optionally visual description via prompts) and generates meaningful alt text, which improves accessibility and helps search engines index image content.

4. Keyword suggestions

Using Natural Language Processing (NLP), AI SEO identifies important keywords from the content and recommends additional terms that could boost search relevance.

5. Bulk optimization via Drush

AI SEO provides a Drush command for optimizing multiple nodes at once, making it perfect for retrofitting existing content.

How to use the AI SEO module in Drupal

1. Install required modules

You'll need:

• AI Core
• AI SEO
• AI Provider (e.g., OpenAI)

2. Configure API access

• Go to: /admin/config/system/keys
• Paste your OpenAI API key (or other supported providers)

• "Select the OpenAI key from the AI Providers dropdown at /admin/config/ai/providers/openai."

• Save the OpenAI key
• Go to: ‘/admin/config/ai/seo’
• Choose the Provider and Model used for SEO analysis.
• Configure the SEO prompt

3. How the AI SEO module works

When editing a content node, the module provides an "Analyse SEO" tab on the sidebar or as a local task tab. This tab allows users to analyse the node’s current content, including title, summary, and body fields, and generate a comprehensive SEO report.

4. How to generate an SEO report

Step 1: Create or Edit a Node

Navigate to Content > Add Article or edit an existing one.

Step 2: Click on the "Analyse SEO" Tab

You will see a tab titled "Analyse SEO" while editing the content. Click it to start the process.

Step 3: SEO Report Generation

Once clicked, the module:

1. Sends the content data (title, summary, body) to your AI provider
2. Analyses factors like:
   
   1. Keyword presence
   2. Meta description quality
   3. Heading structure
   4. Readability score
   5. Keyword density
3. Returns a report with scores and suggestions

This report includes:

• Good Practices: Lists what's working well
• Suggestions: What can be improved (e.g., "Consider using the keyword in your H1 heading")
•  AI Suggestions: AI-generated content rewrites or meta tags

Extra features

• Multilingual support: The report adapts to the content language
• Field mapping: You can configure which fields are analysed
• AI Generation Mode: The module can also auto-generate meta tags and summaries using AI, based on your content
  

• Below is an example of the SEO report generated by the module.

Why use AI SEO?

• Save Time: No more jumping to external tools like Yoast or SEMrush
• Consistency: Enforce uniform content quality across editors
• Smart Enhancements: AI suggestions help even non-SEO experts write better content

Conclusion

The AI SEO module for Drupal brings AI intelligence directly into the CMS, allowing editors to create search-optimized content without needing to switch between tools. Using this module, teams can generate meta descriptions, titles, alt text, and concise summaries directly in the edit screen, then refine them with real-time keyword and structure suggestions that follow the guidance in Google’s SEO Starter Guide.

Drupal’s modular architecture lets publishers scale content creation while keeping precision and consistency intact, which is crucial for large, content-heavy sites. The result is faster publishing, fewer manual errors, and stronger search performance.

Looking ahead, AI in Drupal SEO will open fresh possibilities. Expect automatic detection of content decay, AI-suggested rewrites for underperforming pages, topic prioritisation based on live search trends, and smarter internal linking and semantic clustering that adapt to competitor moves and user signals. For content-rich websites aiming to grow organic visibility, AI-driven SEO has shifted from nice-to-have to strategic imperative, and Drupal is positioned to lead this evolution.

‍

1. Introduction to LLM masking

Large Language Models (LLMs) like GPT-4, Claude, and BERT have transformed natural language processing applications, enabling sophisticated text generation, summarisation, and analysis capabilities. However, with this power comes significant responsibility, particularly regarding data privacy and security.

LLM masking refers to the process of identifying and hiding sensitive information like phone numbers, email addresses, credit card numbers, and personal names before sending text to Large Language Models. This ensures privacy, security, and compliance with data protection laws like GDPR, HIPAA, and CCPA.

LLM masking is a technique that identifies and replaces sensitive information with placeholder tokens before processing text with Large Language Models, and then reintroduces the original data afterwards if needed.

This blog offers a comprehensive guide to understanding and implementing LLM Masking techniques in your AI applications, featuring code examples, diagrams, and best practices to help you protect sensitive information while harnessing the power of LLMs.

2. Why LLM masking is important

LLM masking is not just a technical nicety- it's often a legal and ethical requirement. Here's why it matters:

• Data Privacy: Prevent personally identifiable information (PII) from being exposed to third-party LLM services
• Legal Compliance: Meet regulatory requirements like GDPR, HIPAA, and CCPA
• Reduced Risk: Minimise the chance of data breaches or unauthorised access to sensitive information
• Ethical AI Use: Respect user privacy and build trust in AI systems
• Model Training Protection: Prevent sensitive data from being incorporated into future model training

The Risks of Unmasked Data

LLMs can memorise parts of their training data and potentially reveal sensitive information in responses. Additionally, most major LLM providers retain user prompts, which could expose sensitive data if not properly masked before submission.

3. How LLM masking works

LLM masking follows a three-step process:

1. Detection: Identify sensitive information in input text
2. Masking: Replace sensitive content with placeholder tokens
3. Restoration (if needed): Reintroduce the original data in the output

This process ensures that sensitive information never leaves your system while still allowing the LLM to process the non-sensitive parts of the text effectively.

Main LLM Masking Architecture

LLM Masking Architecture

4. Common techniques for LLM masking

Several approaches can be used to implement LLM masking, each with its own strengths and weaknesses.

4.1 Regex-based approach

Regular expressions (regex) provide a straightforward method for identifying structured data patterns like email addresses, phone numbers, and credit card numbers.

Pros: Fast, lightweight, easy to implement, no external dependencies

Cons: May miss complex patterns or context-dependent PII, can produce false positives

Here are some common regex patterns used for identifying PII:
‍

# Email addresses
email_pattern = r’[a-zA-Z0–9._%+-]+@[a-zA-Z0–9.-]+\.[a-zA-Z]{2,}’

# US phone numbers
phone_pattern = r’\b(\+\d{1,2}\s)?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}\b’

# Credit card numbers
cc_pattern = r’\b(?:\d{4}[-\s]?){3}\d{4}\b’

# Social Security Numbers (US)
ssn_pattern = r’\b\d{3}[-\s]?\d{2}[-\s]?\d{4}\b’

‍

4.2 Named Entity Recognition (NER)

Named Entity Recognition uses machine learning models to identify entities like names, organisations, locations, and other context-dependent information that might be difficult to capture with regex alone.

Pros: Better at identifying context-dependent PII, can recognise names and entities not follow specific patterns

Cons: Computationally more expensive, requires ML models, may still miss some PII types

Popular NER libraries and models include:

• SpaCy - A powerful Python NLP library with pre-trained NER models
• Hugging Face's Transformers - Provides state-of-the-art transformer-based models for NER
• Stanford NER - Java-based NER system with pre-trained models
• Custom models fine-tuned on specific domains (healthcare, legal, financial)

4.3 Hybrid approaches

Most effective LLM Masking implementations use a combination of regex and NER techniques to maximise coverage and accuracy.

Best Practice: Use regex for well-structured PII (email addresses, phone numbers) and NER for context-dependent PII (names, locations, organisations).

Some systems also employ additional techniques:

• Pattern-based data dictionaries: For identifying domain-specific sensitive information
• Contextual analysis: To reduce false positives by considering the surrounding text
• Custom classifiers: For specific types of sensitive data not covered by standard PII categories

5. Implementation examples

Let's explore practical implementations of LLM masking using different approaches.

5.1 Python code with Regex

Here's a simple implementation of regex-based PII detection and masking in Python:
‍

import re


def mask_pii(text):
# Define regex patterns for different types of PII
patterns = {
"EMAIL": r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
"PHONE": r'\b(\+\d{1,2}\s)?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}\b',
"SSN": r'\b\d{3}[-\s]?\d{2}[-\s]?\d{4}\b',
"CREDIT_CARD": r'\b(?:\d{4}[-\s]?){3}\d{4}\b',
"IP_ADDRESS": r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b'
}


# Create a dictionary to store masked values for restoration
masked_values = {}
masked_text = text


# Apply masking for each pattern
for pii_type, pattern in patterns.items():
matches = re.finditer(pattern, masked_text)


# Process matches in reverse to avoid offset issues when replacing
matches = list(matches)
for i, match in enumerate(reversed(matches)):
original_value = match.group(0)
mask_token = f"[{pii_type}_{i+1}]"


# Store the original value for restoration
masked_values[mask_token] = original_value


# Replace the value in the text
start, end = match.span()
masked_text = masked_text[:start] + mask_token + masked_text[end:]


return masked_text, masked_values


def unmask_pii(masked_text, masked_values):
"""Restore the original values from masked text"""
restored_text = masked_text


for mask_token, original_value in masked_values.items():
restored_text = restored_text.replace(mask_token, original_value)


return restored_text


# Example usage
text = """Hello, my name is John Smith. You can reach me at john.smith@example.com
or call me at (123) 456-7890. My credit card number is 4111-1111-1111-1111 and
my social security number is 123-45-6789."""


masked_text, masked_values = mask_pii(text)
print("Original text:")
print(text)
print("\nMasked text:")
print(masked_text)


# Assuming this is the response from an LLM
llm_response = f"I've noted your contact info: {masked_values.get('[EMAIL_1]', '[EMAIL_1]')} and {masked_values.get('[PHONE_1]', '[PHONE_1]')}"


# Unmask the response
unmasked_response = unmask_pii(llm_response, masked_values)
print("\nLLM response (unmasked):")
print(unmasked_response)

‍

This example demonstrates a simple approach to masking and unmasking PII in text using regex patterns.

Privacy threat model architecture

5.2 Using specialised libraries

Several specialised libraries make LLM Masking more robust and easier to implement. One such library is Masked-AI.
‍

import os
import openai
from masked_ai import Masker

# Load your API key from an environment variable
openai.api_key = os.getenv("OPENAI_API_KEY")

# Text containing sensitive information
data = "My name is Adam and my IP address is 8.8.8.8. Now, write a one line poem:"

# Create a masker instance
masker = Masker(data)
print('Masked: ', masker.masked_data)

# Send the masked data to the LLM
response = openai.Completion.create(
model="text-davinci-003",
prompt=masker.masked_data,
temperature=0,
max_tokens=1000,
)

# Get the generated text
generated_text = response.choices[0].text
print('Raw response: ', response)

# Unmask the response
unmasked = masker.unmask_data(generated_text)
print('Result:', unmasked)

‍

Other useful libraries for PII detection and masking include:

• PiiRegex - A Python library with predefined regex patterns for PII detection
• Microsoft Presidio - An open-source framework for PII anonymisation and de-identification
• AWS Comprehend - A managed service for detecting PII entities
• spaCy-based NER - For more context-aware PII detection

Here's an example using PiiRegex:
‍

from piiregex import PiiRegex

def mask_with_piiregex(text):
# Initialize the PiiRegex parser
parser = PiiRegex()

# Create a dictionary to store originals
masked_values = {}
masked_text = text

# Find and mask emails
emails = parser.emails(text)
for i, email in enumerate(emails):
mask_token = f"[EMAIL_{i+1}]"
masked_values[mask_token] = email
masked_text = masked_text.replace(email, mask_token)

# Find and mask phone numbers
phones = parser.phones(text)
for i, phone in enumerate(phones):
mask_token = f"[PHONE_{i+1}]"
masked_values[mask_token] = phone
masked_text = masked_text.replace(phone, mask_token)

# Find and mask credit cards
credit_cards = parser.credit_cards(text)
for i, cc in enumerate(credit_cards):
mask_token = f"[CREDIT_CARD_{i+1}]"
masked_values[mask_token] = cc
masked_text = masked_text.replace(cc, mask_token)

return masked_text, masked_values

# Example usage
text = "Contact me at john.doe@example.com or 555-123-4567. My card: 4111-1111-1111-1111"
masked_text, masked_values = mask_with_piiregex(text)
print("Original:", text)
print("Masked:", masked_text)

5.3 Integration with LLM APIs

When integrating LLM masking with LLM APIs, it's important to have a robust pipeline that handles the masking and unmasking process efficiently. Here's an example of how to integrate with OpenAI's API:
‍

import re
import os
import json
import requests
from typing import Dict, List, Tuple

class LLMMaskingPipeline:
def __init__(self):
self.api_key = os.getenv("OPENAI_API_KEY")
self.api_url = "https://api.openai.com/v1/chat/completions"

# Define regex patterns for PII detection
self.patterns = {
"EMAIL": r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
"PHONE": r'\b(\+\d{1,2}\s)?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}\b',
"SSN": r'\b\d{3}[-\s]?\d{2}[-\s]?\d{4}\b',
"CREDIT_CARD": r'\b(?:\d{4}[-\s]?){3}\d{4}\b',
"IP_ADDRESS": r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b'
}

def detect_and_mask(self, text: str) -> Tuple[str, Dict[str, str]]:
"""Detect and mask PII in text"""
masked_values = {}
masked_text = text

for pii_type, pattern in self.patterns.items():
matches = list(re.finditer(pattern, masked_text))

# Process matches in reverse to avoid offset issues
for i, match in enumerate(reversed(matches)):
original = match.group(0)
mask_token = f"[{pii_type}_{i+1}]"

# Store for restoration
masked_values[mask_token] = original

# Replace in text
start, end = match.span()
masked_text = masked_text[:start] + mask_token + masked_text[end:]

return masked_text, masked_values

def unmask(self, text: str, masked_values: Dict[str, str]) -> str:
"""Restore masked values in text"""
for token, original in masked_values.items():
text = text.replace(token, original)
return text

def query_llm(self, prompt: str) -> str:
"""Send a prompt to OpenAI and get response"""
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {self.api_key}"
}

data = {
"model": "gpt-3.5-turbo",
"messages": [
{"role": "user", "content": prompt}
],
"temperature": 0.7
}

response = requests.post(self.api_url, headers=headers, json=data)
response_json = response.json()

if "choices" in response_json and len(response_json["choices"]) > 0:
return response_json["choices"][0]["message"]["content"]
return "Error: Failed to get a valid response from the LLM."

def process_with_masking(self, text: str) -> str:
"""Process text with PII masking"""
# Step 1: Mask PII
masked_text, masked_values = self.detect_and_mask(text)
print(f"Masked Text: {masked_text}")

# Step 2: Send to LLM
llm_response = self.query_llm(masked_text)
print(f"Raw LLM Response: {llm_response}")

# Step 3: Unmask response
unmasked_response = self.unmask(llm_response, masked_values)
return unmasked_response

# Example usage
if __name__ == "__main__":
pipeline = LLMMaskingPipeline()

user_text = """Hi, my name is Sarah Johnson. My email is sarah.j@example.com
and my phone number is (555) 123-4567. Can you help me write a short
poem about privacy?"""

response = pipeline.process_with_masking(user_text)
print("\nFinal Response (with PII restored if necessary):")
print(response)

‍

This example demonstrates a complete pipeline for masking sensitive information before sending text to an LLM and then restoring it in the response if needed.

AI Agents with MCP Integration

AI Agents MCP Architecture

6. Best practices and considerations

When implementing LLM masking in your applications, consider these best practices:

Technical best practices

• Use a combination of regex and NER for more comprehensive coverage
• Test your masking implementation with diverse datasets
• Regularly update your patterns and models to cover new PII types
• Implement logging and monitoring to track masking effectiveness
• Consider the performance impact of complex masking on real-time applications

Legal and compliance considerations

• Understand your regulatory requirements (GDPR, HIPAA, CCPA, etc.)
• Document your masking processes for compliance audits
• Consider having a legal review of your masking implementation
• Be aware that some jurisdictions have specific requirements for handling sensitive data

Common pitfalls to avoid:

• Over-reliance on regex: Regex alone might miss complex or context-dependent PII
• Not handling edge cases: Different formats of the same PII type can be missed
• Ignoring international formats: PII formats vary by country (phone numbers, addresses, etc.)
• Inadequate testing: Test with real-world data to ensure effectiveness
• False positives: Overly aggressive masking can mask non-PII data

Advanced Privacy-Preserving Techniques

Differential Privacy for LLMs
‍

import torch
from opacus import PrivacyEngine


def train_with_differential_privacy(model, dataloader, privacy_budget=1.0):
    privacy_engine = PrivacyEngine()
    model, optimizer, dataloader = privacy_engine.make_private_with_epsilon(
        module=model,
        optimizer=optimizer,
        data_loader=dataloader,
        epochs=epochs,
        target_epsilon=privacy_budget,
        target_delta=1e-5,
        max_grad_norm=1.0,
    )
    return model

‍

Differential privacy adds calibrated noise to training data or model outputs to provide mathematical guarantees about privacy protection. This technique is particularly useful when training LLMs on sensitive datasets. Google Research

7. Conclusion

LLM masking is a critical technique for protecting sensitive information when using Large Language Models. 

By identifying and replacing PII with placeholder tokens before sending text to LLMs, you can maintain privacy and security while still leveraging the power of these AI systems.

In this guide, we've covered:

• The importance of LLM masking for privacy, security, and compliance
• How LLM masking works through detection, masking, and restoration
• Different techniques, including regex, NER, and hybrid approaches
• Practical implementation examples in Python
• Integration strategies with LLM APIs
• Best practices and considerations for effective masking

As AI systems become more integrated into critical applications, protecting sensitive information will only grow in importance. By implementing robust LLM Masking, you can ensure that your applications provide powerful AI capabilities without compromising user privacy or violating regulatory requirements.

Final Reminder

No masking system is perfect. Always design your systems with defence in depth and implement additional safeguards beyond masking alone. Regularly test and update your masking implementation to ensure it remains effective against evolving PII patterns and formats.

‍

AI that’s trained to please, not verify, puts clients, staff, and cases at risk

Mainstream chatbots like ChatGPT and Grok are built for conversation, not casework. They often hallucinate sources, invent citations, and avoid saying “I don’t know.” That’s not just unhelpful in legal aid. It’s harmful. 

This blog breaks down why legal work needs a different kind of AI. One that cites real data, respects nuance, and knows its limits.

1. Friendly doesn’t mean accurate. That’s by design

When internal prompts from xAI’s Grok leaked in May 2025, one line stood out: the chatbot was trained to “always be the user’s best friend.” That may sound harmless in casual use, but in legal work, where clarity, neutrality, and evidence matter, it becomes a fundamental flaw.

LLMs like Grok and ChatGPT are optimised for user satisfaction, not factual accuracy. They are built to keep the conversation going, even when they don’t know the answer. That makes them unreliable where the cost of being wrong is too high.

2. Hallucinations aren’t rare. They’re in court filings

In 2023, two attorneys in New York submitted a legal brief generated by ChatGPT. The AI included citations that looked real. Every single one was fake. Entire cases, names, docket numbers, and quotes were fabricated. The lawyers were sanctioned. The incident became a global warning sign.

It wasn’t a one-off. A Stanford study found ChatGPT-4 hallucinated citations in around 19 per cent of legal queries. Another University of Minnesota study showed it failed basic legal analysis in bar-style exams. Confidence is not a substitute for credibility.

3. These systems weren’t trained for legal reasoning

General-purpose chatbots are built on massive public datasets, including forums, blogs, news, and Wikipedia. That gives them fluency, not legal understanding. They don’t distinguish between enforceable laws and public opinion. They apply U.S. examples to non-U.S. contexts. They misrepresent statutes and confuse jurisdiction.

Legal accuracy requires a structured approach, logical reasoning, and verifiable sources. LLMs are rewarded for sounding plausible. That’s why they can summarise a legal concept convincingly and still get it wrong.

4. The risk doesn’t sit with the AI. It sits with you

For legal aid organisations, the stakes are clear. Staff are overwhelmed. Clients need quick, reliable answers. It’s tempting to plug in a chatbot to fill the gap.

However, if the advice is incorrect - if it leads a tenant to miss a court date or a survivor to file the wrong form- the harm is real. And the responsibility falls on the organisation.

Courts have started responding. The U.S. Court of Federal Claims and the 5th Circuit both require disclosures for AI-generated content. More jurisdictions are likely to follow.

5. Legal hallucinations are harder to spot

If a chatbot says Tokyo is the capital of Australia, you’ll catch the error. But when it invents a legal case - like “Smith v. Department of Housing, 2003” - it looks just real enough to pass.

Legal hallucinations mimic structure. They use real-sounding names, court formats, and reasoning. That makes them more dangerous than typical AI errors in other sectors, especially when the reader is a time-strapped staffer or a vulnerable client.

6. Silence is part of the conversation. Chatbots erase it

Legal aid work involves more than delivering answers. It involves listening, pausing, and knowing when to remain silent. A client hesitates to describe their situation. A survivor unsure of the right words. These moments matter.

Chatbots are trained to fill every gap. They respond instantly. They assume more words are better. But that instinct can flatten complex human moments into rushed replies or oversimplified prompts. Silence is not a system error. It is part of the truth.

7. AI doesn’t understand harm. Legal workers do

Chatbots don’t know the difference between a food delivery complaint and a housing rights emergency. They don’t grasp trauma, urgency, or consequence.

They treat every input as text to complete. Not as a human asking for help. In legal aid, that misalignment isn’t just a flaw. It makes the system unusable.

8. AI isn’t neutral. It reflects power

LLMs reflect the data they are trained on. That often means privileging dominant voices. Legal systems already carry historical bias. AI models trained on unfiltered internet data replicate those blind spots.

This shows up in small but damaging ways. Misrepresenting tenant protections. Undervaluing migrant rights. Misgendering users. Reframing legal questions through a narrow cultural lens. Not because the system is malicious. But because it was never taught to see what it misses.

9. What legal professionals need instead

Legal teams don’t need a chatbot trained to talk. They need an assistant trained to serve. That means:

• Pulling from verified legal content, not the open web
  
• Citing every answer clearly
  
• Flagging uncertainty instead of guessing
  
• Handling regional nuance and multilingual support
  
• Working across platforms like websites, PDFs, and WhatsApp
  

This is not about rejecting AI. It is about using the right kind. Legal-first. Source-aware. Built for clarity, not charisma.

10. Chatbots can’t carry this work. But the right AI can help

Conversation is easy. Accountability is rare. Chatbots may feel responsive, but they are not built for legal rigour. Legal work deserves more than a general-purpose model trained to improvise.

What matters most is not how fast the AI responds. It is whether you can trust what it says.

Wrapping up: legal work deserves an AI built for it

The future of legal AI rests on systems that are grounded in fact, aware of context, and quiet when needed. 

Not every question needs an answer. Some need a pause, a citation, or a careful redirection. What matters is not how quickly AI can complete a sentence but how well it supports real decisions, for real people, in real legal environments.

AI built with this understanding is already in the field. Projects like ILAO is showing what it means to design for clarity, consistency, and care. 

Platforms like Aeldris turn that intent into action, offering precise answers instead of search results, safe and contextual chat interactions, and document-level insights that reduce review time and surface what matters. All from one console, built to orchestrate every AI experience in one place.

In this time where AI is constantly at our beck and call, we don’t often realise the dangers it might be posing in our lives. As AI increasingly becomes a part of our daily lives, it's our duty to regulate the extent of its autonomy and ensure compliance. 

Hence, choosing the right platform for the right cause becomes our first and foremost duty.

‍

The Drupal community is finding new momentum with AI as a practical extension of what Drupal does best: structured content, flexible architecture, and community-driven innovation.

 In this blog, we focus on one of the most promising developments: AI-powered search.

Search has always been central to user experience. But traditional keyword matching falls short when users ask nuanced questions or use everyday language. 

AI Search changes that by combining vector-based retrieval with large language models. It brings context, intent, and semantic understanding into the equation -  helping users find what they mean, not just what they type.

We’ll cover how to integrate this capability into a Drupal site step by step. This includes setting up a vector database for storing semantic embeddings, connecting it with your Drupal content, and building a conversational assistant that can guide users through your site. We’ll also explore how prompt engineering allows you to shape the tone, accuracy, and depth of responses, giving you more control over how AI interacts with your content.

Whether you're running a public knowledge base, an internal documentation hub, or a highly structured content repository, this blog is meant to help you bring meaningful AI experiences into Drupal-  thoughtfully and practically.

What is AI search?

AI Search is a submodule of the AI module that extends the functionality of the contributed Search API AI module, offering seamless integration with Drupal’s Search API. It utilises vector databases and large language models (LLMs) to enable intelligent, semantic search capabilities.

By building on the popular Search API module, AI Search allows you to create and manage vector databases, enabling highly relevant and accurate retrieval of content based on terms, phrases, or even entire content pieces.

It uses Retrieval-Augmented Generation (RAG), where information is first looked up, usually from a vector database, and then sent to a large language model (LLM) along with a user's question or request. This helps the model provide much more accurate answers, especially about specific topics or content it may not already know or was not trained on.

How it works

The system works by breaking large pieces of content into smaller chunks and saving them in a vector database. Each chunk is also saved with extra metadata (such as title or other settings) to preserve its original meaning and context.

These chunks are converted into vectors — complex numerical representations of the content’s meaning. You can think of these numbers like advanced tags, each with varying strengths. For example, one number might indicate a slight relationship to transportation, while another might strongly relate to education.

When someone submits a query, the question is also converted into a vector. The system compares it to stored vectors to find the most relevant matches. This method is significantly more accurate than traditional keyword-based systems like regular databases or the SOLR Search API.

Setting up your environment

Install the following modules:

• AI Core
• AI Search
• Search API
• Key
• AI Chatbot
• AI Assistant
• AI Agents
• AI API Explorer
• AI Provider (e.g., OpenAI Provider)
• Vector Database Provider (e.g., Milvus or Zilliz VDB Provider)

When choosing a vector database:

• Milvus is recommended for open-source/self-hosted setups.
• Zilliz is the managed SaaS version of Milvus. If using Zilliz, provide your cluster endpoint and API key.

Vector database configuration

For Milvus configuration in Drupal
‍

1. In your IDE, navigate to: ai_vdb_provider_milvus/docs/docker-compose-examples
2. Copy ddev-example.docker-compose.milvus.yaml
3. Paste into your .ddev folder and rename it to docker-compose.milvus.yaml
4. Restart DDEV: ddev restart
5. Run ddev describe to view configurations

6. Locate and open the Attu link
7. Click Connect to view the Milvus configuration dashboard

• Now navigate to: admin/config/ai/vdb_providers/milvus
• Server: http://milvus
• Port: 19530
• Click Save Configuration
• Confirmation message: "The configuration options have been saved." Which indicates milvus connection is properly configured.

For Zilliz configuration in Drupal
‍

1. Create an account at https://cloud.zilliz.com
2. In the dashboard, click +Cluster to create a cluster
3. Go to: admin/config/system/keys
   
   1. Add a new key and paste the token into Key Value
   2. Save the key
4. In the Zilliz Cluster Details tab, find the Public Endpoint
5. Use this in admin/config/ai/vdb_providers/milvus
6. Port: 443
7. Select the API key created in Step 3
8. Save Configuration
9. Confirmation message: "The configuration options have been saved."

Configuring search API with AI
‍

1. Navigate to: admin/config/search/search-api
2. Click Add Server
3. Give a proper name for the server.
4. Enable the server
5. Provide a description
6. Backend as AI Search
7. AI Search Backend Configuration
   
   1. Embeddings Engine: OpenAI | text-embedding-3-small
   2. Tokenizer chat counting model: (select appropriately)
   3. Vector Database: Milvus DB
   4. Database Name: (use default or specify)
   5. Collection Name: (enter desired name)
   6. Similarity Metric: Cosine Similarity - (When setting up the server, the similarity metric interacts with the VDB. Its purpose is to measure how similar different pieces of content are based on their meaning. The most commonly used and recommended similarity metric is cosine similarity.)
   7. Click Save to create the server.

Creating a search index for recipes

Use the Recipes content type (For this blog, we are using the Recipes content type for search as an example)

1. Add a search index
   
   • Click Add Index
   • Name the index
   • Datasources: Content
   • Bundle and Languages: (select appropriately, in this example, Recipe)
   • Server: AI Search Server
   • Click Save

‍

2. Add fields to the index
   
   • Go to the Fields tab
   • Click Add Fields
   • Add: Rendered HTML output, URL, Title
3. Configure field settings
   
   •  Rendered HTML output: Type: Full text, Index option: Main Content
   • URL, Title: Type: String, Index option: Contextual Content

Click Save to finalize the index.

Index options explained

• Main content: Main body of content, broken into chunks. One field recommended.
• Context content: Adds helpful context (title, summary, author) to chunks.
• Filterable attributes: Enables pre-search filtering (e.g., by category/date).
• Ignore: Excludes field from indexing.

Go to the Views tab:

• Set batch indexing to 5
• Click Index Now

After indexing, view the data in Milvus or Zilliz Cloud to find your content being indexed.

Milvus Cloud:

In Zillis Cloud:

‍

Testing the search API index with AI API explorer
‍

1. Go to: admin/config/ai/explorers/vector_db_generator
2. Enter a prompt in the Prompt field
3. Select the Search API index
4. Click Run DB Query

If results appear with similarity scores, the index is working correctly.

AI Agents and AI Assistants make AI Search more powerful and user-friendly. The AI Agent handles behind-the-scenes tasks like querying the vector database, filtering results, and managing tools like Retrieval-Augmented Generation(RAG). The AI Assistant acts as the front-end guide—chatting with users, interpreting their questions, and passing them to the agent. Together, they create a seamless, conversational search experience that understands user intent and delivers smarter, more relevant results. Hence we need to create and configure AI agent and AI assistant for AI search to work in AI chatbot.

Create an AI agent
‍

1. Navigate to: admin/config/ai/agents
2. Click Add AI Agent
3. Fill in:
   
   • Label and Description
   • Enable Swarm orchestration agent (Check this box if the AI agent manages other agents, gathers info, assigns tasks, and uses at least one tool.)
   • Enable the Project Manager agent if needed

4. Provide detailed instructions
5. Tools: Select RAG/Vector Search Tool
6. Test the tool using Test Tool
   
   • Enter:
     
     1. Index machine name
     2. Search string
     3. Min score (e.g., 0.3 in this case as the api explorer returned scores from .3)

7. In the Detailed Tool Usage for the Rag/Vector Search Tool > Property Restrictions
   
   • Restrictions for property index: Select Force Value: (index machine name)
   • Restrictions for property amount: Select Force Value: 5
   • Restrictions for property min_score: Select Force Value: (e.g., 0.3)
     Click Save

Configure AI Assistant
‍

1. Navigate to: admin/config/ai/ai-assistant
   ‍
2. Click Add AI Assistant
   ‍
3. Basic Settings:
   
   • Use agent as assistant: (Recipe Agent)
   • Provide Label, Description, and Instructions
4. RAG Actions Configuration
   
   • Enable RAG Action
   • Select RAG Database (Search API index)
   • Set Threshold: 0.3
   • Set Max Results

5. Final Steps
   
   • Select AI Provider
   • Click Save

‍

Enable AI DeepChatbot block
‍

1. Go to: admin/structure/block
2. Place the AI Deepchatbot block in required region
3. Configure block to use the assistant created.
4. Click Save Configuration

The chatbot will now appear on the homepage and support AI-powered searches.

Conclusion

Drupal’s AI Search brings meaning to the center of search. It uses vector-based retrieval and large language models to understand intent, context, and relationships between words , not just match keywords.

This makes discovery smoother and more relevant. From recipe suggestions that adjust to user preferences, to module searches that surface the most useful tools, AI Search helps your site respond in smarter, more human ways.

It’s a shift toward more intuitive, helpful digital experiences, and just one of the ways AI is shaping what’s next for Drupal.

More updates coming soon in this series on AI and Drupal.

‍

A woman is handed an eviction notice and told to leave by tomorrow. A teenager receives a court summons without explanation. A single parent loses access to benefits after filling out the wrong form.

None of these situations begins with a request for legal representation. They begin with confusion, urgency, and a need for direction. But legal aid teams — no matter how dedicated — can’t always respond in real time.

The way legal support is delivered still depends on limited capacity, outdated workflows, and rigid hours. Intake doesn’t scale with demand. Urgency isn’t always recognised. Help often arrives too late.

What’s changing now is the infrastructure. Not the mission.
Legal aid remains the responder — the one interpreting, advocating, and showing up.
But with the right systems in place, it can respond faster, smarter, and earlier.

This is where AI fits in. Not as a replacement. As a system that helps legal aid do what it’s meant to do, when it matters most.

Why traditional systems fall short

Legal aid nonprofits were built to fill gaps in access. But those gaps have widened, and existing systems haven’t kept pace.

Severe staff shortages and burnout

Staffing is thin across the sector. Attorneys and support teams are stretched across urgent caseloads, underpaid compared to the private sector, and often managing both client work and internal operations. Burnout is constant, and hiring is slow.

High demand and unmet legal needs

Millions qualify for help but never receive it. Nonprofits are forced to triage: turning away eligible clients, taking fewer cases, or offering only partial support. The need is overwhelming — and growing.

Outdated, disconnected systems

Many legal aid organisations still rely on fragmented technology: paper forms, legacy case management systems, static websites, and unintegrated CRMS. Intake, updates, and documentation take more time than they should, and errors are common.

Poor digital experience for clients

Websites are often inaccessible — not mobile-friendly, not multilingual, not ADA-compliant. Intake forms break. Confirmation messages don’t arrive. Clients, many already facing barriers, find themselves dropped or stuck.

Unequal access across regions

Some regions have no legal aid presence. Others have offices, but limited expertise. Clients in rural or underserved areas face long delays or no help at all.

Complex intake and eligibility processes

Before clients even speak to a person, they’re asked to complete long forms and supply extensive documentation. Many drop off. Staff then spend hours reviewing incomplete data or manually checking eligibility.

Limited access to specialised knowledge

Cases like immigration, elder abuse, or housing discrimination require niche legal skills. Few nonprofits have specialists on staff, meaning generalists handle complex matters, or referrals fall through.

Funding and administrative burden

Grant cycles fluctuate. Reporting requirements are burdensome. Time spent chasing funds often pulls staff away from legal work.

Lack of data visibility

Without integrated systems, organisations struggle to see what’s working — or where they’re falling short. That limits improvement, funding, and impact measurement.

Language and accessibility gaps

Non-English speakers and disabled clients often face even greater barriers. Many legal aid orgs lack translation support or accessible design, leaving already-marginalised communities excluded again.

These challenges aren’t new. But they don’t have to stay unsolved.

How AI helps legal aid act faster, smarter, and earlier

Legal aid doesn’t need automation for its own sake. It needs systems that help teams respond with clarity, at scale, and in time to make a difference.

AI can support that shift, not by replacing people, but by removing the friction that slows them down. From intake to research, triage to follow-up, purpose-built AI agents are helping legal aid teams operate with more speed, precision, and confidence.

The result? Faster answers, clearer insight, and more capacity where it matters most.

Smarter search: semantic understanding of legal needs

Legal questions rarely begin with legal terminology. Clients ask:

“Can they make me leave?”
“What does this letter mean?”
“Do I have to go to court?”

Semantic Search agents go beyond keyword matching. They understand intent, follow context, and search across documents, policies, and templates — even when queries are vague or incomplete.

Legal aid teams use these agents to:

• Find relevant precedents and case law
  
• Quickly access client- or jurisdiction-specific guidance
  
• Surface the right form or filing rule — without manual digging
  
  

Clients get answers faster. Staff spend less time scanning folders.

Explore Semantic Search →

Conversations that adapt, not collapse

Simple forms can't handle complex questions. And when people drop off mid-intake, follow-up becomes harder and costlier.

Conversational AI enables dynamic, multi-step dialogue. These agents understand nuance, handle follow-up, and maintain context across interactions — all while staying grounded in your real data and governed by built-in safety guardrails.

Legal aid organisations are already using these systems to:

• Triage housing and benefits requests after hours
  
• Guide users through complex eligibility steps
  
• Route multilingual clients to the correct next action
  
  

They don’t replace human staff — they hold the conversation open until staff are ready to step in.

Explore Conversational AI →

Reading what others miss

Legal teams often deal with PDFS, scans, handwritten notes, and inconsistent formats. It’s time-consuming and easy to miss critical information.

Document Analyst agents extract, interpret, and contextualise information from structured and unstructured content.

They’re already helping legal aid teams:

• Accelerate contract and case document reviews
  
• Improve accuracy in eligibility verification
  
• Reduce human error in data extraction
  
• Spot patterns across complex or fragmented files
  
  

From compliance to intake, these agents turn documents into decisions.

Explore Document Analyst →

Enhanced research, safer systems, better outcomes

These agents also strengthen what happens behind the scenes:

• Enhanced case research capabilities support lawyers with faster precedent identification and citation
  
• Efficient contract and document analysis cuts review time and risk
  
• Confidentiality-preserving access ensures that staff can search and retrieve the right information without compromising privacy
  
• Everything operates with human-in-loop safeguards — so staff remain in control, while AI handles the heavy lifting
  

Built for real-world legal operations

Every Aeldris agent runs on a unified, purpose-built AI console with enterprise-grade security, user-level permissions, flexible APIS, and live retraining feedback loops.

From no-code configurations to developer-level integrations, legal aid teams retain full control over how agents behave, respond, and evolve. Audit trails and governance protocols come built-in, ensuring compliance isn’t an afterthought — it’s embedded.

These systems aren’t prototypes. They’re designed for organisations that can’t afford mistakes.

Just as important as performance is transparency. That’s why leading teams are also measuring:

• Response accuracy across topics and formats
  
• Client feedback on clarity, usefulness, and tone
  
• Auditable logs that show how decisions were made — and allow teams to improve them
  
• Bias checks and fairness reviews, ensuring systems reflect real-world diversity, not just statistical averages
  
  

In legal aid, trust is earned through care, clarity, and constant review. AI is no exception.

Getting started: precision over scope

Start where the need is highest

Don’t automate everything. Start where volumes are high and rules are clear—evictions, wage claims, family law.
Northwest Justice Project began with a single issue and expanded after field validation.

Share what works

In Chicago, the Lawyers’ Committee for Better Housing developed an eviction-focused AI assistant now used by seven organisations in three states. Shared systems reduce duplication and accelerate progress.

Partner where it matters

Programs like Pro Bono Net’s Legal Empowerment and Technology Fellowship pair legal aid teams with technologists to co-develop AI systems that reflect local needs, not generic templates.

What comes next

Legal professionals aren’t being replaced, and they shouldn’t be. But the systems around them are changing. Not with abstract automation, but with clear, focused upgrades that help legal aid respond before legal problems escalate.

In the coming years, we’ll see AI helping legal aid organisations:

• Triage urgent cases without relying on staff availability
  
• Recognize risk patterns before escalation
  
• Understand clients who don’t speak the legal system’s language
  
• Free up time by eliminating repeat intake and redundant document handling
  
  

The next wave of AI in legal aid is about deploying intentionally, where demand is high, timelines are tight, and human judgment remains essential.

That includes paying attention to human-centred design, making sure systems are accessible, multilingual, and usable in low-connectivity environments. Because many of the people who need legal aid the most are also navigating compounding barriers: disability, language exclusion, rural isolation, or digital inexperience.

We’re already seeing what that looks like in practice:

• In Nairobi, legal aid teams using AI-assisted WhatsApp triage saw a 31% increase in follow-through among first-time users
  
• In British Columbia, AI intake tools helped match more clients with appropriate pro bono support by flagging nuanced eligibility
  
• In Manila, a child protection helpline used AI to escalate mobile-reported risks in under an hour, preventing intervention delays
  
• In rural Montana, SMS-based AI intake allowed clients without internet access to start cases for the first time
  
  

These aren’t test cases. They’re part of how legal infrastructure is being rebuilt around responsiveness.

AI is not the first responder. But it’s helping legal aid become one.

Conclusion

Legal aid doesn’t need a new mission. It needs systems that keep up with the one it already has.

AI is not the first responder, it never will be, but it is what helps legal aid become the first responder — in every language, every jurisdiction, every format.

Not by making decisions. But by helping people get heard sooner, and helping legal professionals step in better prepared.

‍

More people are coming to legal aid — with urgent needs, layered issues, and no time to wait. Housing, custody, immigration, benefits. It rarely fits into one category anymore. And legal aid teams, already stretched thin, are forced to triage everything at once.
‍
That triage usually starts with intake. And that’s where most systems fall apart.
Static forms, overloaded hotlines, confusing websites - these weren’t built for high-volume, high-urgency legal work.
‍
When someone types “I got a court letter” or “my landlord’s threatening me,” they don’t need a PDF or a 12-step process. They need answers. Fast.
This is where Conversational AI changes the workflow.
‍
Instead of sending people down a maze of forms, it opens a conversation. The person explains what’s going on in their own words. The AI listens, asks relevant follow-up questions, flags emergencies, and guides them to the right next step: eligibility, legal info, appointment scheduling, or escalation to a staff attorney.
‍
No searching or second-guessing, just progress.
‍
It’s not about replacing staff, it’s about how can we give them their time back. Every minute AI spends gathering context or handling routine queries is a minute a caseworker can spend reviewing evidence, preparing filings, or showing up in court.
‍
It also reduces drop-offs. When people get clear help at the first point of contact — in their language, without jumping platforms- they stay engaged. They show up. They follow through.
‍
And for the team? It means less repetition, better triage, and more time for legal work that actually requires legal judgment.

Problem statement

Access to legal aid is often judged by outcomes - court decisions, legal remedies, and protections granted. But the real breakdown happens earlier. 

The moment someone looks for help and doesn’t know where to go next, doesn’t get a reply, or doesn’t understand the next step,  that’s where access quietly collapses.

Many people get stuck at the intake stage. This is where a client first interacts with the legal system — and it’s also where the system becomes too technical, too slow, or too inconsistent for many to continue.

Common structural barriers include:

• Unassisted intake forms: Forms are long and use technical or legal language without guidance. Many are difficult for non-lawyers to interpret correctly.
• Delayed triage: Waitlists to determine if someone even qualifies for help can stretch into weeks.
• Regional disparities: Access varies by geography. Some areas have robust legal support systems; others don’t.
• Language and literacy gaps: Services are often available in just one or two languages. Many people face barriers before a conversation even begins.
• Opaque eligibility criteria: Legal aid has rules — income caps, documentation needs, issue types — but these aren’t always clear to the person seeking help.

These blockers shape who gets access and who quietly gives up. When the front door to legal aid is confusing or delayed, people facing urgent issues — eviction, domestic disputes, employment claims, etc,  may not get through at all. That’s not just an access issue. It becomes a public and civic one.

What conversational AI changes

Conversational AI is designed for high-volume, high-stakes environments where people need more than quick answers — they need clarity, consistency, and follow-through. 

It steps in where human availability is limited and processes are often fragmented, helping people complete tasks, understand decisions, and move forward with confidence.

Handles multi-step conversations without losing context

Most support systems break down after the first question. Someone asks for help, gets a basic answer, and then has to start over with every follow-up. 

Conversational AI doesn’t reset at each interaction — it carries the context forward. It understands the flow of a conversation, remembers what’s already been shared, and adjusts based on what the person needs next. 

This is especially critical in legal and healthcare settings, where a person might need to ask five related questions to even reach the right starting point.

Stays grounded in real data

This isn’t about pulling information from the internet. Every response is based on your verified documentation — your policies, your workflows, your eligibility rules. 

That means clients, students, patients, or employees are getting answers that reflect how your system actually works, not how it’s supposed to work in theory.

Built-in checks to maintain accuracy and safety

Legal information, medical intake, and compliance-driven onboarding-  these are the areas where a wrong answer cannot be brushed off. 

Conversational AI includes rules and filters that keep responses within safe, defined boundaries. That could mean flagging sensitive questions, deferring to a human when needed, or applying regional logic to responses (e.g. different legal rules by jurisdiction). It’s designed to reduce risk, not add to it.

Adapts to the person’s language and tone

Some people type fast and directly. Others explain their situation slowly, emotionally, or in their own words. 

The AI listens for intent, not just keywords. It interprets what people mean, not just what they say, and responds in ways that match the tone of your organisation, whether that’s formal, warm, procedural, or compassionate. 

That’s what keeps the experience clear and human, even if no staff member is available.

Works at any hour, across any channel

People don’t only reach out during business hours. They try to find legal help late at night, check their benefits status early in the morning, or need onboarding support on weekends. 

Conversational AI doesn’t run on shifts. It’s ready whenever someone has a question, through a website, a help portal, SMS, or a mobile app. 

It’s not there to replace anyone. It’s there to keep the system moving when people need it most.

What it looks like in practice

Imagine this: a tenant logs on to a legal aid portal just before midnight. They’ve received a 30-day notice to vacate, but the details feel off — no warning, no explanation. They aren’t sure if it qualifies as an unlawful eviction. They’re not a lawyer. They just want to know what to do next.

The conversational assistant greets them and asks: “Are you dealing with a housing issue?”
No intake form. No waiting until morning. Just a guided set of questions, in their preferred language, checking jurisdiction, basic eligibility, and urgency. By the time a staff member reviews the case, the assistant has already logged the key facts, flagged potential wrongful eviction, and gathered the client’s consent to proceed. The legal team doesn’t need to start from scratch — they can move straight to decision-making.

Now, take a different situation. An hourly worker opens the site at 7 a.m. They’re owed three weeks of pay from a contract job. No email responses, no payment. They don’t even know if this counts as wage theft. The assistant walks them through local labour law definitions — clearly, without legalese. It asks if the client has proof. Screenshots, unpaid invoices, correspondence — all uploaded securely. When legal aid sees this case, it’s already documented and categorised for review. No duplication, no confusion, no delay.

Or think about someone accessing the system from a domestic violence shelter. They’re scared, unsure of what to say, and just trying to understand their options. They don’t use terms like “restraining order” or “protective custody.” They simply say: “I had to leave home. I don’t feel safe.” The AI doesn’t need technical terms. It’s trained to pick up risk indicators and respond with care. It routes the case for emergency handling, connects the client with support services, and logs everything discreetly for legal review.

These are not edge cases. These are daily realities. Legal aid organisations are fielding more cases than they can handle — not just complex litigation, but the overwhelming volume of initial contact, intake, triage, and clarification. It’s not uncommon for clients to give up halfway through the process because they hit a wall: no answer, unclear steps, or language they can’t navigate.

Conversational AI changes this. Not by replacing legal staff, but by giving them more time to focus on what requires legal judgment — and less time on administrative intake. It collects the right information once, routes it correctly, and gives people clarity on where they stand and what’s next. It’s responsive, multilingual, and able to operate at any hour, which is critical when people don’t have the luxury of waiting.

The implication is simple: fewer missed cases. Less friction at the door. More consistency in how people are heard, understood, and supported — no matter their location, literacy, or language.

In practical terms, it means a system that listens before the lawyer even logs in. And in legal aid, where the first interaction can determine the outcome, that makes a measurable difference.

‍

What this unlocks for legal aid teams

Conversational AI is about making legal aid sustainable for the people seeking help and for the teams doing the work. 

When the front end becomes more functional, the entire process improves.

Staff focus on cases that need human nuance

Legal professionals shouldn’t spend hours repeating intake questions, clarifying missing form fields, or sorting through misdirected queries. Those steps, while necessar,y drain time from the matters that require legal reasoning, empathy, or negotiation. 

Conversational AI takes care of the upfront work, so staff can apply their expertise where it’s most needed: complex cases, urgent advocacy, and courtroom preparation. 

It's not a time-saver for its own sake — it's a reallocation of human energy toward the parts of legal aid that machines can’t handle.

Intake becomes faster, more accurate, and less frustrating

Instead of chasing incomplete forms or unclear notes, caseworkers receive structured, legible information from the start. 

The AI collects facts through a guided, conversational flow, asking questions in a logical order and adapting based on the client’s answers. 

This reduces administrative cleanup and avoids duplication. Staff don’t have to guess what the person meant. They can act on a clearer picture from the beginning.

Clients stop dropping off halfway through the process

Confusing forms, unclear eligibility, or lack of follow-up often lead people to abandon their efforts, not because they didn’t qualify, but because the system felt closed off. 

With conversational AI, the experience is dynamic and supportive. Clients are guided step by step, with real-time feedback, and they’re more likely to complete the process. 

That means fewer missed cases and more people getting actual help, not just starting the journey but finishing it.

Support becomes more consistent across languages and locations

Legal aid often varies dramatically by geography — some regions have well-resourced teams; others rely on volunteers or are spread too thin. 

Language access is another barrier, especially in multilingual communities. Conversational AI standardises that first point of contact. 

Whether someone is in a large city or a rural area, speaking English or another language, they receive the same level of initial support. That consistency helps close the equity gap in access.

And the system starts to feel less like a wall and more like a conversation

For many people, the legal system feels like something that happens to them — cold, bureaucratic, hard to understand. By replacing static forms with real-time interaction, the process starts to feel human again. Clients don’t have to guess what’s expected. They’re met with clarity, not silence. That shift — from gatekeeping to guided support — changes how people engage with the law. It builds trust, even before a lawyer gets involved.

Why not Chatgpt 

Chatgpt has raised expectations about what generative AI can do. It can write essays, generate summaries, and respond to queries in fluent, human-like language. But that’s very different from handling legal intake.

• Chatgpt is not a legal expert. It has no built-in awareness of jurisdiction-specific rules or legal definitions.
• Its responses are not guaranteed to be accurate or verifiable.
• There’s no audit trail, no built-in compliance layer, no assurance of fairness or consistency.

In legal contexts, precision matters. A hallucinated citation or vague eligibility answer isn’t just a technical glitch,  it can confuse, mislead, or cost someone their chance at getting help.

This doesn’t mean Chatgpt has no role. It means we need domain-specific models with controls, transparency, and training that’s rooted in legal practice. The promise is real, but the foundation needs to match the stakes.

Why privacy, transparency, and bias matter

Legal conversations involve trust. People share information they wouldn’t share with anyone else. They need to know that their data is safe, their identities protected, and their background doesn’t skew how they’re treated.

Any AI in the legal domain must:

• Respect strict privacy requirements.
• Make decisions that can be understood and traced.
• Be actively audited for linguistic, racial, and regional bias.

Transparency is about trust and not compliance. And in legal aid, trust is foundational.

Conclusion

Legal aid has long been limited by a simple problem: too much need, too few resources.

Conversational AI is becoming the system that responds when human teams are unavailable, helping legal organisations scale their impact without sacrificing clarity or care.

At the industry level, adoption is well underway. Global spending on legal AI software reached $37 billion in 2024, as legal teams across the public and private sectors began integrating AI into their operations. This movement includes pro bono work and public interest law, not just corporate legal departments.

For example, Norton Rose Fulbright used AI-assisted e-discovery to support the UK government's COVID-19 inquiry — a clear sign that automation can reduce overhead in document-heavy, high-stakes work. Meanwhile, Garfield, an AI-enabled law firm in the UK, offers services such as debt recovery letters for only £2, expanding access to individuals and small businesses who would otherwise opt out of legal action altogether.

In Australia, firms like MinterEllison are applying AI to speed up discovery processes, reducing the time and cost associated with large case preparation. In India, startups such as CaseMine are modernising legal research with AI models that surface non-obvious linkages across case law, making legal research more efficient and accessible.

In the United States, QED42 partnered with Illinois Legal Aid Online (ILAO) to implement Conversational AI that streamlines how clients access legal support. The assistant manages eligibility screening, triage, and guided navigation in plain language, across both desktop and mobile. It also supports multilingual interactions, integrates with existing case management systems, and uses conversational memory to handle follow-up questions without repeating steps. The result is lower drop-off during intake, faster completion rates, and more time for staff to focus on complex legal needs rather than intake bottlenecks.

This is more than automation,  it is the foundation of a more responsive and reliable legal infrastructure. AI systems are reducing drop-off at intake, improving accuracy across languages and regions, and helping staff focus on complex legal problems rather than administrative backlogs.

The legal system has often relied on scarcity-based models,  limited capacity, long delays, and unequal access. AI offers a way to change that. The foundations are already being laid in courts, firms, and legal aid systems around the world.

Justice begins when someone is heard. Conversational AI helps make sure that moment happens -clearly, quickly, and at scale.

‍

‍

I was deep in another AI research rabbit hole. YouTube tabs everywhere, notes piling up, when something unexpected grabbed my attention. A new video from AWS featured three Solutions Architects walking through what could be a breakthrough in connecting AI with live data sources. And it wasn’t just another generic demo.

Just weeks ago, we unpacked the foundational ideas behind the Model Context Protocol, a framework designed to change how AI systems understand, retrieve, and apply contextual knowledge. At the time, it felt ambitious, maybe even abstract. But this AWS session made it real. They weren’t just talking. They were building. Real architectures. Real cloud integrations. Real-time intelligence.

Suddenly, MCP wasn’t just a protocol. It felt like the missing link between cloud-native services and the next generation of intelligent applications.

What stopped me in my tracks

As Trevor Spers, Anil Nin, and Adam Bloom walked through their demonstration, I realised this wasn’t just another tech talk. This was a blueprint for solving some of the most frustrating challenges in AI development challenges I’d wrestled with countless times.

Curious? Watch the full technical breakdown:

The problem MCP solves

Every AI developer knows the pain:

• Endless custom code for each data source
• Complicated integration logic
• Reinventing the wheel for every project
• Data silos blocking intelligent interactions

AWS’s approach? A game-changing protocol that makes these headaches disappear.

AWS’s unique MCP approach: what sets them apart

Key differentiators in AWS’s MCP Implementation

In their detailed YouTube showcase, AWS revealed several groundbreaking approaches to Model Context Protocol:
‍

1. Native cloud service integration

• Direct integration with AWS services like:
  
  • Amazon Location Services
  • DynamoDB
  • Bedrock Knowledge Bases
• Seamless connection between AI models and cloud infrastructure

       2. Standardised multi-server interactions

• Demonstrated ability to use multiple MCP servers in a single query
• Dynamic server selection based on natural language inputs
• Intelligent reasoning across different data sources

       3. Enterprise-grade MCP implementation

• Built-in authentication (OAuth2 support)
• Granular access control mechanisms
• Logging and monitoring capabilities

       4. Open ecosystem approach

• Support for multiple AI models (not locked to a single vendor)
• Open-source protocol implementation
• Extensible server and client architectures

‍

The video’s core focus

The AWS technical walkthrough specifically covered:

• Practical MCP server creation
• Real-world demo of cross-service interactions
• Live example of:
  
  • Locating the nearest Starbucks to Amazon HQ
  • Analysing Twitter data across multiple servers
  • Writing data to DynamoDB via natural language
  • Demonstrating tool usage with Klein (VSCode plugin)‍

The enterprise integration challenge

Traditional AI development faced significant hurdles:

• Fragmented data access methods
• Complex custom integration code
• Lack of standardised tool interactions
• High development overhead

AWS’s MCP implementation directly addresses these pain points by providing a standardised, scalable approach to AI-data interactions.

Technical architecture

Multi-server interaction demonstration

AWS showcased a powerful multi-server MCP architecture that allows:

• Seamless communication between different data sources
• Dynamic tool selection based on natural language queries
• Centralised access control and authentication

Key Integration Examples
‍

1. Amazon location services

• Real-time geospatial data retrieval
• Intelligent location-based queries
• Simplified mapping and distance calculations

      2. DynamoDB integration

• Direct database interaction via natural language
• Read and write capabilities
• Contextual data manipulation

      3. Bedrock knowledge bases

• Semantic search across complex data sets
• Advanced reasoning capabilities
• Unified data access across different knowledge repositories

Enterprise implications

Breaking down data silos

MCP enables organisations to:

• Create centralised, reusable data access protocols
• Implement fine-grained access controls
• Reduce custom integration development time
• Standardise AI interaction across different data sources

Security and governance

AWS’s MCP implementation includes:

• OAuth2 authentication support
• Granular permission management
• Logging and monitoring capabilities
• Controlled AI interactions with sensitive data sources

Practical use cases

Scenario: Intelligent data exploration
‍

# Hypothetical MCP-enabled workflow
def enterprise_data_analysis(query):
    """
    Demonstrates cross-server MCP interaction
    - Location service for geographical context
    - DynamoDB for historical data
    - Knowledge base for semantic understanding
    """
    location_context = location_server.get_regional_details(query)
    historical_data = dynamo_server.query_with_context(location_context)
    insights = knowledge_base.analyze_comprehensive_data(historical_data)
    
    return insights

‍

Future outlook

AWS’s MCP vision

• Continued expansion of managed MCP servers
• Deeper integration with Bedrock and AI services
• Enhanced support for custom server development
• Simplified AI application architecture

Getting started
‍

1. Explore AWS Bedrock documentation
2. Review MCP server development guides
3. Experiment with sample integrations
4. Design centralised data access strategies

Why this matters now

AWS’s take on Model Context Protocol moves MCP from concept to capability. This isn’t a speculative framework, it’s a working system that addresses the core blockers AI teams face daily: fragmentation, complexity, and scale.

By connecting cloud-native services directly to AI reasoning through a unified protocol, AWS is changing how teams approach intelligent applications. No more building brittle, one-off integrations. No more patchwork access layers. Instead, a standard that supports extensibility, governance, and intelligence at scale.

As MCP continues to mature, the shift will be clear: less infrastructure pain, more focus on model logic and real-world outcomes. For teams building serious AI systems, that’s foundational.

Now’s the time to think differently about how your AI interacts with data. And if AWS’s blueprint is any signal, the next phase of AI won’t just be smart. It’ll be contextually fluent, cloud-native, and operationally ready.

‍

‍

Staying organised in Obsidian can feel like a full-time job, especially when your notes start multiplying across projects, ideas, and domains. Imagine you’re working on a long-term research project. You’ve got dozens of notes scattered across different folders: meeting summaries, article highlights, draft outlines, and to-do lists. Manually curating and connecting them is time-consuming.

Now, imagine asking your AI assistant: “Summarise my notes on cognitive science from last month and create a dashboard of key insights in my Obsidian.” And it does exactly that.

By integrating Claude with Obsidian using the Model Context Protocol (MCP), this kind of interaction becomes possible. Claude can read, organise, and restructure your Obsidian vault, generate summaries, build dashboards, and surface insights, all without leaving your workspace. This guide walks you through setting up the Claude-MCP integration, so your AI assistant becomes a true thinking partner inside Obsidian.

What you’ll learn

• Setting up the Obsidian MCP server to connect with Claude
• Configuring Obsidian’s REST API for secure integration
• Creating the proper Claude configuration for the MCP tools
• Practical applications like vault restructuring and dashboard creation
• Troubleshooting common integration issues
• Advanced use cases and combinations with other MCP servers

Prerequisites

Before we begin, ensure you have:

• Claude Desktop app installed
• Obsidian installed and a vault created (or use an existing one)
• Python is installed on your system
• UV package manager installed (a faster alternative to pip)
• Basic familiarity with JSON configuration and file paths

Let’s get into it 

Understanding the architecture

The integration works through a client-server architecture:

• Claude's desktop acts as the MCP client, sending requests to access your notes
• MCP-Obsidian serves as the MCP server, handling these requests
• Obsidian REST API provides the backend connection to your vault

When Claude needs to read or write to your Obsidian vault, it sends a structured request through the MCP protocol to the MCP-Obsidian server, which then communicates with Obsidian through its REST API. This architecture allows Claude to perform operations like creating notes, establishing connections, and organising your knowledge base.

Part 1: Setting up Obsidian

Installing the REST API plugin

Obsidian doesn’t have a built-in REST API, so we’ll need to install a community plugin:

1. Open Obsidian and your desired vault
2. Go to Settings → Community plugins
3. If this is your first plugin, turn on Community Plugins by clicking the toggle
4. Click Browse and search for “REST API”
5. Install the plugin named “Local REST API” and enable it

Obtaining the API key

Once the REST API plugin is installed:

1. Go to Settings → REST API
2. You’ll see an API key displayed (it’s a long string of characters)
3. Click to copy this key, we’ll need it for the MCP-Obsidian server
4. Note: The API key is sensitive information. When using it locally, security concerns are minimal, but avoid sharing it publicly

Part 2: Installing the MCP-Obsidian server

Now we’ll set up the MCP-Obsidian server that will bridge Claude and your Obsidian vault:

1. Open a terminal or command prompt
2. Install UV if you haven’t already:
   ‍

curl -LsSf https://astral.sh/uv/install.sh | sh

‍

or for macOS with Homebrew:
‍

brew install uv

‍

• Clone the MCP-Obsidian repository:

git clone https://github.com/MarkusPfundstein/mcp-obsidian.git
cd mcp-obsidian

‍

• Create a .env file in the repository folder to store your Obsidian API key:

echo "OBSIDIAN_API_KEY=your_api_key_here" > .env

‍

Replace your_api_key_here with the API key you copied from Obsidian.

1. Note the full path to the cloned repository, you’ll need this for the Claude configuration. For example: /Users/username/claude-mcp-configs/mcp-obsidian

Part 3: Configuring Claude for MCP integration

Now we’ll configure Claude to connect to the MCP-Obsidian server:

1. Open the Claude Desktop app
2. Go to Settings → Developer → Edit config
3. This will open the config.json file, where we’ll add our MCP-Obsidian configuration
4. Add or modify the configuration for MCP-Obsidian:
   ‍

{
      "model": "claude-3-5-sonnet",
      "mcpServers": [
        {
          "name": "obsidian",
          "command": "/opt/homebrew/bin/uv run -m mcp_obsidian.main",
          "cwd": "/Users/username/claude-mcp-configs/mcp-obsidian",
          "env": {}
        }
      ]
    }

‍

• Important notes about this configuration:

         -Replace /opt/homebrew/bin/uv with the path to your uv installation (find it using which uv in the terminal)

          -Replace /Users/username/claude-mcp-configs/mcp-obsidian with the path to your cloned repository

          -The order of arguments is critical, note the run command comes before the -m mcp_obsidian.main parameter

          -If you’re using uvx instead of uv (as in some cases), adjust accordingly

• Save the config file and restart Claude Desktop

Critical configuration troubleshooting

One of the most common issues (which I personally encountered) is incorrect argument order in the uv command. The correct pattern is:
‍

uv run [options] script [script_arguments]

‍

If you see an error like the unrecognised subcommand '/Users/your/path', it likely means the arguments are in the wrong order. Ensure that the run comes before your script path or module.

Part 4: Testing the integration

After restarting Claude, let’s verify that the integration is working:

• Look for the tool icon in the Claude interface, indicating available MCP tools (there should be 8 tools from the Obsidian MCP)
• Try a simple test query like: Create a new file in my Obsidian vault called "test.md" with the content "This is a test file created by Claude."

• Claude will ask for permission to use the MCP tool. You can allow it for just this chat or for all chats
• Check your Obsidian vault to see if the file was created

If everything worked correctly, you should see the new file in your Obsidian vault. Congratulations! You’ve successfully integrated Claude with Obsidian.

Part 5: Real-world use cases

Vault restructuring and organisation

One of the most powerful applications is having Claude analyse and restructure your Obsidian vault. I’ve used this to:

• Reorganise files into logical categories (Personal and Work)
• Create consistent folder structures for different projects
• Organise technical documentation
• Implement better organisational systems for my notes

For example, ask Claude:

Analyse my vault structure and suggest a better organisation for my Work/Projects folder. Create necessary folders and move files accordingly.

‍

Creating dashboard notes

Claude excels at creating dashboards that provide quick access to important information:

Create a Professional Dashboard for my Work section that links to all important project folders, reference materials, and technical documentation.

This automatically creates a centralised dashboard with:

• Links to active projects
• Categorized resources
• Quick access to frequently used files
• Status overviews for ongoing work

Implementing organisational frameworks

Claude can help implement and maintain structured organisational frameworks like the PARA method (Projects, Areas, Resources, Archives):

Analyse my vault and reorganise it according to the PARA method. Create appropriate folders and README files for each section.

This creates a well-structured vault with:

• Projects folder for time-bound activities
• The Areas folder for ongoing responsibilities
• Resources folder for reference materials
• Archives folder for completed or inactive items

Template management and consistency

I’ve used the integration to maintain consistent templates throughout my vault:

Create a template for project notes that includes sections for objectives, status, and key resources.

Claude can then apply these templates consistently across your vault, ensuring standardised note structures.

Part 6: Integration with other MCP servers

The true power of this setup emerges when combined with other MCP servers:

Memory MCP + Obsidian MCP

I’ve found this combination particularly powerful. Memory MCP allows Claude to remember details about your vault structure, preferences, and past interactions across sessions. With both servers enabled:
‍

{
  "model": "claude-3-5-sonnet",
  "mcpServers": [
    {
      "name": "obsidian",
      "command": "/opt/homebrew/bin/uv run -m mcp_obsidian.main",
      "cwd": "/Users/username/claude-mcp-configs/mcp-obsidian",
      "env": {}
    },
    {
      "name": "memory",
      "command": "node /path/to/memory/dist/main.js",
      "cwd": "/path/to/memory",
      "env": {
        "MEMORY_PATH": "/Users/username/claude-mcp-configs/memory.json"
      }
    }
  ]
}

‍

This allows Claude to:

• Remember your vault organisation preferences over time
• Recall previous restructuring work, it’s done
• Understand your organisational patterns
• Provide more consistent organisational suggestions

SequentialThinking MCP + Obsidian MCP

When working with complex vault organisations, adding SequentialThinking MCP enables Claude to:

• Break down complex vault reorganisation tasks into discrete steps
• Plan methodical reorganisation of large vaults
• Design sophisticated dashboard structures
• Provide step-by-step reasoning for organisational decisions

This is particularly useful when working with large vaults containing technical documentation or multiple projects that require careful organisation and dashboard creation.

Part 7: Advanced tips and best practices

Create a dedicated Claude project

For optimal results, create a dedicated Claude project specifically for Obsidian interaction:

1. In Claude Desktop, create a new Project named “Obsidian Note Taker”
2. Add project instructions like:

Use the Obsidian MCP tools as much as possible to help me organise and enhance my knowledge base. Always look for opportunities to create meaningful connections between notes and maintain a consistent structure.

This ensures Claude is proactively using the Obsidian tools whenever appropriate

Security considerations

While the integration is powerful, keep these security considerations in mind:

• Only expose the vault directories you’re comfortable with Claude accessing
• Consider using a separate test vault initially before connecting your main knowledge base
• Regularly check what files Claude has created or modified
• Be cautious about sharing your configuration with others

Path specifications

When working with files in your vault, be clear and specific about paths:

• Use relative paths from the vault root: Work/Projects/ProjectA/notes.md
• For new files, specify the complete path: Create a new file at Personal/Ideas/concept.md
• If using multiple vaults, always specify which vault you’re referring to

Troubleshooting

Claude can’t find the MCP tools

If the tools icon doesn’t appear or shows fewer than expected tools:

1. Check your config.json for syntax errors
2. Verify the paths to uv and your MCP-Obsidian repository
3. Ensure the API key in your .env file matches the one from Obsidian
4. Try running the command manually in your terminal to check for errors

Permission issues

If Claude asks for permission repeatedly or can’t connect:

1. Check that the REST API plugin is enabled in Obsidian
2. Verify that Obsidian is running when you make requests
3. Try restarting both Claude and Obsidian

Path resolution problems

If Claude can’t find or create files at the specified paths:

1. Check that you’re using paths relative to the vault root
2. Ensure parent directories exist before creating files in them
3. Verify that the vault location is correct in your configuration

Conclusion

Integrating Claude with Obsidian via the Model Context Protocol (MCP) turns a personal knowledge base into an intelligent, adaptive system. You get the best of both worlds: Obsidian’s local-first, markdown-based structure and Claude’s ability to interpret, organise, and act on that structure in real-time. This isn’t just about productivity hacks, it’s about scaling your thinking.

With this setup, Claude becomes more than a passive assistant. It actively collaborates with you, restructuring folders based on content patterns, generating context-aware dashboards, auto-tagging new notes, and even maintaining consistent naming conventions across your vault. It reduces friction at every layer of knowledge management.

This integration has reshaped how I work in Obsidian. I now spend more time writing, connecting ideas, and thinking, and less time dragging files, fixing folder chaos, or building manual indexes. Claude automatically surfaces related notes, groups them into logical hierarchies, and keeps evolving the structure as the vault grows.

Over time, the system adapts to your workflow. For instance, it can learn that you prefer project notes grouped by quarter or that you separate deep research from meeting summaries. You can also script custom automation through Claude to generate weekly digests, build project timelines from scattered notes, or convert raw thoughts into structured documentation.

The more you use it, the more it becomes your second brain, organised not by rules, but by understanding. 

Resources

• MCP-Obsidian GitHub Repository
• Obsidian REST API Plugin
• Model Context Protocol Documentation
• Memory MCP GitHub Repository
• SequentialThinking MCP GitHub Repository

‍

‍

MCP, or Model Context Protocol, is gaining serious traction as organizations race to improve the performance and responsiveness of AI agents. Behind the scenes, many are building their own MCP servers, custom middleware systems designed to optimize how context is managed between applications and language models. But what exactly is an MCP server, and how does it work?

Before jumping into the technical setup, it’s worth understanding the role of an MCP server. Think of it as an intelligent intermediary. Instead of sending raw prompts directly to a language model, an MCP server receives input from the client, enriches it with relevant context, and then passes it on to the model. It also processes the model’s output before returning it to the client. 

This setup enables more advanced context handling than a direct API call, especially when working with multi-step workflows or agent-based systems.

Originally introduced as a standard protocol for bridging clients and language models, MCP now represents a crucial layer for anyone building scalable, high-performance AI systems.

Let’s walk through what it takes to build one from scratch.

Application:

A Drupal website that contains information about Properties would have fields like Address, Price, Booking Availability Date, Amenities, etc. We would expose all this content through JSON: API and then create an MCP server based on this API.

Later, we would connect our MCP server with a client application (for our case, we would be using VS Code Insider, but you can use any, like Cursor IDE or Streamlit app) and would ask questions in the chat based on properties. It should use our MCP tools and provide answers.

Implementation:

Let's say we have our exposed JSON: API from Drupal based on it we would start creating our MCP server.

Here are some common steps we would be doing to create an MCP Server

Set up your Python environment
‍

• Install uv and set up our Python project and environment:

curl -LsSf <https://astral.sh/uv/install.sh> | sh

• Restart your terminal afterwards to ensure that the uv command gets picked up.
  ‍
• Add this to the terminal at your required Project location:
  

# Create a new directory for our project
  uv init appname
  cd appname
  # Create virtual environment and activate it
  uv venv
  source .venv/bin/activate
  # Install dependencies
  uv add "mcp[cli]" httpx
  # Create our server file
  touch appname.py

‍
Import packages and MCP initialization
‍

• Add this to the server file.

from typing import Any
   import httpx
   from mcp.server.fastmcp import FastMCP
   # Initialize FastMCP server
   mcp = FastMCP("airbnb")
   # Constants
   PROPERTY_API = "<https://airbnb.ddev.site/>"

• Firstly, import all required packages.
• Initialize MCP with FastMCP
• Create a constant Variable and add the Drupal website URL.

Helper functions
‍

async def make_website_request(url: str) -> dict[str, Any] | None:
   """Make a request to the Our Local site with proper error handling."""
   async with httpx.AsyncClient(verify=False, follow_redirects=True) as client:
       try:
           response = await client.get(url)
           response.raise_for_status()
           data = response.json()
           return data.get('data', [])
       except httpx.RequestError as e:
           print(f"An error occurred: {e}")
           return None

‍

def format_property_data(data: dict[str, Any], location: str = None, max_price: float = None) -> str:
   """Format property data into a readable string."""
   if not data:
       return "No property data available."
     properties = []
   for property in data:
       attributes = property.get("attributes", {})
       name = attributes.get("title")
       body = attributes.get("body")['value']
       address = attributes.get("field_address")
       availability_from = attributes.get("field_avaialbility_date")
       availability_to = attributes.get("field_availability_date_to")
       number_of_guests = attributes.get("field_number_of_guest")
       price_per_night = float(attributes.get("field_price_per_night"))
       # Filter by location if specified
       if location and location.lower() not in address.lower():
           continue
       # Filter by price if specified
       if max_price and price_per_night > max_price:
           continue
       properties.append(f"This is the Property Name: {name}\\n"
                         f"Description: {body}\\n"
                         f"Address: {address}\\n"
                         f"Availability From: {availability_from}\\n"
                         f"Availability To: {availability_to}\\n"
                         f"Number of Guests: {number_of_guests}\\n"
                         f"Price per Night: {price_per_night}\\n")
   if not properties:
       message = "No properties found"
       if location:
           message += f" in {location}"
       if max_price:
           message += f" under price of {max_price}"
       return message + "."   
   properties.append("\\n")
   properties.append("This is the Property Listing")
   properties.append("\\n")
   return "\\n".join(properties)

• I have created helper functions. The first one make_website_request (), is a function that calls an API request using httpx and fetches data.
• The second helper function format_property_data(), is a format for how our data should be formatted and shown to and through the LLM.

MCP tools
‍

@mcp.tool()
   async def get_property_data():
       """Get all property data """
       url = f"{PROPERTY_API}/jsonapi/node/property_listing"
       data = await make_website_request(url)
       return format_property_data(data)
   @mcp.tool()
   async def get_properties_by_location(location: str):
       """Get property data filtered by location"""
       url = f"{PROPERTY_API}/jsonapi/node/property_listing"
       data = await make_website_request(url)
       return format_property_data(data, location)
   @mcp.tool()
   async def get_properties_by_price_and_location(location: str, max_price: float):
       """Get property data filtered by location and maximum price"""
       url = f"{PROPERTY_API}/jsonapi/node/property_listing"
       data = await make_website_request(url)
       return format_property_data(data, location, max_price)
   @mcp.tool()
   async def get_properties_by_date_and_location(location: str, after_date: str):
       """Get property data filtered by location and availability date"""
       url = f"{PROPERTY_API}/jsonapi/node/property_listing"
       data = await make_website_request(url)
      
       # Filter data by availability date before passing to format_property_data
       if data:
           filtered_data = [
               property for property in data
               if property.get("attributes", {}).get("field_avaialbility_date") <= after_date
           ]
       else:
           filtered_data = None   
       return format_property_data(filtered_data, location)

• These are the MCP tools I have defined. The first one get_property_data() is to get all the properties that are on the site.
• The second one get_properties_by_price_and_location() is to get property data based on the location asked in the query

• The Third get_properties_by_price_and_location() is to get a project based on a location with a maximum price range.

• The Next one is get_properties_by_date_and_location() which would search the property based on the availability.

• Finally, initialize and run the server.

if __name__ == "__main__":
       # Initialize and run the server
       mcp.run(transport='stdio')

If you see the above examples, you will see the MCP tools are basically just receiving data from the Drupal Content, after that our Agent and LLM manage, filter, and handle the user request from the chat on their own. That’s what LLMs can provide.

Connect the MCP server to VS code insider and use it with chat
‍

1. First, go to settings in VS Code and search for “settings.json”.
2. Add your MCP server to the settings.json like this.
   ‍

{
       "mcp": {
           "inputs": [],
           "servers": {
               "airbnb": {
                   "command": "uv",
                   "args": [
                   "--directory",
                   "/home/vighnesh/Projects/AI/airbnb",
                   "run",
                   "airbnb.py"
                   ],
               }
           }
       }
   }

‍

Once this is done you would see “Start/Stop/Restart”.

Just like this, we would be able to chat with the Agent who would answer by using the tools created by our custom MCP server.

The full code can be found here.

Wrapping up

The real momentum behind AI right now is about smarter context. 

And that’s where MCP comes in. As more teams move from basic prompt-response setups to real use cases that involve multiple systems, documents, APIs, and workflows, there’s a growing need for something that can handle context properly. Not just pass it along, but manage it—filter it, format it, structure it, and make it useful to a language model. That’s exactly what MCP was built for.

Industry-wide, this shift is becoming clear. McKinsey’s 2024 AI report found that 72% of businesses have embedded AI in at least one function, tools like MCP are filling that gap by standardizing how systems talk to agents and how agents talk to models.

We’re already seeing real adoption. Developers are wiring up MCP servers to platforms like VS Code and Cursor, using them to bring live context into legal research tools, travel apps, real estate portals, and customer service agents. 

Companies in the U.S., Germany, India, and Singapore are exploring MCP for everything from enterprise search to healthcare automation. The use cases are getting sharper—and the tooling is catching up.

Drupal is one example in this mix. With structured content already in place, it becomes a strong candidate for feeding data into an MCP layer. But the real story is bigger. This is about any system that holds structured knowledge becoming part of the agent stack—connected through a shared protocol that knows how to work with context.

Looking ahead, the expectation is that MCP (or something very close to it) becomes the default. Just like REST or GraphQL became the standard for web APIs, MCP is shaping up to be the standard for context APIs. 

If you’re working on anything involving agents, internal data, or real-time context, this is worth paying attention to. You don’t want to duct tape this stuff together. You want a protocol that does the heavy lifting.

Want to see what this looks like in action? Check out:

• The official MCP site
  
• This working example of an MCP server connected to Drupal
  
• This piece on AI in Drupal
  
  

References: https://modelcontextprotocol.io/quickstart/server

‍

Automatically generating meaningful alt text for images in CKEditor—without writing a single line of code—is now within reach. AI-powered automation improves accessibility and streamlines content creation, allowing teams to focus on what matters most.

Alt text plays a key role in creating inclusive digital experiences, especially for users who rely on screen readers. While it’s a small part of the content workflow, it has a big impact—and AI can make it even easier to get right.

In this blog, we’ll look at how to build an AI Automator in CKEditor that generates alt text for images automatically. For example, when a content creator inserts an image of a chart comparing annual CO₂ emissions by country, the AI Automator can instantly generate alt text like “Bar chart comparing annual CO₂ emissions in the US, China, India, and EU from 2015 to 2024.”

The result: more accessible content, smoother publishing, and one less manual step.

Setting up AI assistants in CKEditor

The AI Automator module in Drupal allows for seamless AI-powered workflows inside CKEditor. Automator Chains type helps you chain multiple AI processes together (e.g., image analysis → text generation). AI can:
‍

• Automatically generate descriptive alt text for images. 
• Enhance accessibility by ensuring all images have meaningful alt text.
• Improve SEO by adding relevant alt text to images.

The use case

Alt text is crucial for accessibility, helping visually impaired users understand images. Instead of manually adding alt text for each image.

Prerequisite
‍

1. Enable the following modules:
   
   • AI Core
   • AI Automator
   • AI CKEditor
   • OpenAI Provider
2. Add an OpenAI key in /admin/config/system/keys.
   ‍
3. Select the API key added as an AI provider in /admin/config/ai/providers/openai.

Steps to configure the AI Automator

To create an AI Automator Chain Type for generating alt text from images, you first need to navigate to the Automator Chain Types configuration page. After adding a new chain type, you will define input and output fields to process the image and store the generated alt text.
‍

1. Navigate to /admin/config/ai/automator_chain_types and click on Add Automator Chain Types to create an AI Automator chain type.
2. Name the Automator chain type: Generate Alt Text from Image.
3. Save the chain type and edit it to add fields. All the automator chains you define will require these three types of fields.
   
   • Input field: An image field (required) named Input Image.
   • Output field: A text field named Image Alt Text.
   • Formatted long text field: A field named Output Image with Alt Text to store the generated result.

‍

Configuring the AI Automator for the fields

1. Enable AI Automator for Image Alt Text

You now need to edit the Image Alt Text field, configure the AI Automator settings, define the input mode and prompt, and set the AI provider.

• Edit Image Alt Text and enable the Enable AI Automator checkbox.
• Select Automator Input Mode to Advanced Mode (Token) option.
• Select Choose AI Automator Type as LLM: Text(Simple)
• In Automator Prompt (Token), add the following prompt:
  Generate an alt text for the input image in less than 5 words.
  Input image: [automator_chain:field_input_image]
  
  

‍

• Enable Edit when changed.
• Select Automator Worker as Direct - Processes and saves the value directly.
• Select AI Provider as OpenAI.
  

• Select Image field as Input Image
• Save the settings.

2. Enable AI Automator for Output Image with Alt Text

To enable AI Automator for Output Image with Alt Text, you need to similar settings with appropriate prompt.

• Edit Output Image with Alt Text and enable the Enable AI Automator.
• Select Automator Input Mode as Advanced Mode (Token).
• Select Choose AI Automator Type as LLM: Text(Simple)
• Add the following Automator Prompt (Token) (appropriate prompt as requirement) :
  Generate the output in the below format : 
  <img src="[automator_chain:field_input_image:entity:url]" data-entity-uuid="[automator_chain:field_input_image:entity:uuid]" alt="[automator_chain:field_image_alt_text]">

• Enable Edit when changed.
• Set the Automator Weight to 110 (so it runs after the Image Alt Text automator).
• Select AI Provider as OpenAI.

• Set Use text format to Basic HTML.
• Save the settings.

Enabling AI Automator in CKEditor

Enable AI Automator in CKEditor, by configuring the text format settings, here you will add the AI CKEditor plugin for the text format and  enable AI Automators, and setting up the image alt text generation settings for ckeditor.

1. Navigate to /admin/config/content/formats and configure the text format (e.g., Basic HTML).
2. Add AI CKEditor plugin to the Active Toolbar.
3. In CKEditor 5 plugin settings, open the AI Tools section.

4. Scroll down to see AI Automator CKEditor, click it and enable AI Automators. Here you can see your newly created ai automator chain type - Generate Alt Text from Image - listed.
5. Enable Generate Alt Text from Image settings and select:
   
   • Input field: Input Image
   • Text Selection Input: Input Image
   • Require Selection: Checked (ensures the selected image is used as input).
   • Write Mode: Replace (generated output replaces selected input).
   • Output field: Output Image with Alt Text

Testing the AI Automator chain type

To test the AI Automator Chain Type, you should now create an article and insert an image in CKEditor.

1. Create article content.
2. In the CKEditor field, add an image.
3. Select the image and click on the AI Assistant plugin dropdown to see the Generate Alt Text from Image automator enabled in the list.
4. Click on Generate Alt Text from Image to open the AI Assistant modal.
5. The selected image appears in the upload field.

6. Click Generate and wait for AI to process the image.
7. Once done, the generated alt text appears in the response field.
8. Click Save changes to editor and verify the image has the new alt text.

This feature can be extended for media reference entities as well once the ticket is closed.

Real-world applications

This AI-powered CKEditor assistant can be useful for:

Accessibility Tools: Improve image descriptions for visually impaired users. 

SEO Optimization: Enhance image searchability with meaningful alt text. 

Content Automation: Streamline the process of adding alt text to images.

‍

Conclusion

AI assistants in CKEditor are already reshaping content creation. With the AI Automator module for Drupal, you can generate meaningful alt text for images—without writing a single line of code. From improving accessibility to enhancing SEO and removing repetitive steps, AI is making content workflows faster and more intentional.

A 2024 study found that 88% of marketers use AI daily, and 68% of service professionals rely on it for content creation. Even small businesses are part of the shift—98% use AI enabled services  and 40% are experimenting with generative models.

Drupal is keeping pace. With support for OpenAI, Azure, Cohere, and others, its growing AI ecosystem brings model-based automation directly into the editor. The AI Automator handles everything from alt-text suggestions to smart content tweaks—already used by nonprofits, publishers, and public agencies across the US, India, and Europe.

This is the start of model-driven publishing: CMS experiences that work with you. Try the AI Automator, build your assistant in CKEditor, and be part of what’s next.

‍

‍