The two AI integrations that matter

Cut through the noise and there are two AI integrations that consistently pay for themselves on a Drupal site:

  1. RAG over your Drupal content — turn the CMS into a knowledge base your visitors can actually ask questions of.
  2. AI-assisted editorial workflows — give editors AI as a power tool inside the node edit form.

Everything else is interesting in demos and disappointing in production. We've shipped both patterns at scale and we'll go deep on each below.

RAG over your Drupal content

The architecture, end-to-end:

  1. On every node save, generate embeddings for the node title, body, and key fields
  2. Store those embeddings in a vector database (Pinecone, Weaviate, Qdrant, or PgVector if you already have Postgres)
  3. When a visitor asks a question, embed the question, vector-search for the top-N relevant nodes
  4. Send the top-N node bodies as context to an LLM, ask it to answer the question grounded in that content with citations
  5. Render the answer with clickable citations linking back to the source nodes

The pattern that breaks people: forgetting to re-embed on node update, ending up with stale vectors, then arguing with editors that the AI is "wrong" when actually it's looking at three-month-old content.

The hardest part of production RAG isn't the LLM — it's the embedding pipeline. Treat the vector store as a derivative of the content database, not as a separate truth.

Implementation patterns

  • Embedding on node save — hook_entity_update, queue worker, background processing
  • Re-embedding on schema change — full reindex when you change which fields contribute to the embedding
  • Cite by entity reference — never let the LLM hallucinate URLs; pass node IDs and have your renderer convert them to canonical URLs
  • Cache the question → answer — same question, similar context, identical answer — don't pay for the LLM call twice

AI-assisted editorial workflows

The features that consistently move the needle for content teams:

  • One-click summary — generate the node summary field from the body, editable before save
  • SEO meta generation — meta description and Open Graph title from the body, in the brand voice
  • Translation — auto-translate to the next language in a multilingual site, with the original kept as ground truth
  • Taxonomy auto-tagging — propose taxonomy terms with confidence scores, editor approves
  • Brand voice check — flag phrasing that deviates from the brand guidelines you've trained on
  • Alt text generation — generate alt text for uploaded images, editor approves

The thread that runs through every one: generate, editor approves. Never auto-save AI output to a published field. Always show it as a suggestion. Editors who feel in control will use the feature daily; editors who feel overridden will turn it off.

The modules worth using

The Drupal AI ecosystem has consolidated. As of mid-2026 the modules we reach for first:

  • AI module — provider-agnostic AI abstraction layer. Wire it once, swap providers without rewriting code.
  • AI Content Suggestions — sits inside the node edit form; one-click summary, alt text, meta description.
  • Search API AI — RAG-flavoured retrieval inside the existing Search API pipeline.
  • OpenAI / Anthropic / Gemini providers — discrete provider modules that plug into the AI module.
  • Embedding storage — Pinecone, Weaviate, Qdrant, or PgVector provider modules for the AI module.

Provider choice: OpenAI vs Claude vs Gemini vs self-hosted

Our defaults in 2026:

  • OpenAI GPT-4o family — strongest default for editorial workflows. Wide language coverage, fast, well-documented.
  • Anthropic Claude — strongest for long-document understanding and faithful citation. Default for RAG-heavy use cases.
  • Google Gemini — strongest when you're already on Google Cloud and care about Vertex AI Agent Engine integration.
  • Self-hosted Llama 3.x via vLLM — when data residency or air-gap requirements mean you can't send content to a third-party API.

Evals, guardrails, and audit logging

The three things you need before you call any AI feature production-ready:

  • Evals — a fixed test set of representative inputs with expected behaviour, run on every model update. We've seen production behaviour quietly drift across provider model updates more than once.
  • Guardrails — input filtering for PII, output filtering for prohibited content, length and rate limits.
  • Audit logging — every LLM call, with the prompt, the response, the user, the node ID. Boring until it isn't — and when it isn't, it's compliance-critical.

What to avoid

  • Public-facing chatbots without RAG — they confidently lie and you have no way to defend the answer.
  • AI-generated content auto-published — editor approval is non-negotiable.
  • Tightly coupling to one provider — use the AI module's abstraction so you can swap providers when pricing or quality changes.
  • Ignoring the embedding-staleness problem — re-embed on update or accept the consequences.
  • Skipping evals — model behaviour changes silently across provider updates. Without evals, you don't know it broke until a user complains.

If you're planning AI features for a Drupal site and want a sanity check on the architecture before you start building, get in touch. We do this every week and we'll save you the first three mistakes.