Create a chat model, a vector store, and pass them together with your documents to simpleRAG(). It handles loading, splitting, embedding, storing, and retrieval automatically. The following example creates a simpleRAG service, ingests documents from a local folder, and answers a question:

To extend your Adobe subscription using a prepaid card, follow these steps: 1. On the prepaid card, locate your redemption codeph beneath the scratch-off foil on the back of the card. 2. Select the appropriate link based on your product type, such as Creative Cloud, Acrobat, or any specific version you have. 3. Sign in using your Adobe ID and password. 4. Follow the onscreen instructions to complete the redemption process. This will add the subscription period to your existing account.

The source parameter accepts a single file path, a folder path (all supported files are indexed recursively), a URL, or an array of any combination:

• expandPath('./docs/handbook.pdf') — single file path
• expandPath('./knowledgebase/') — folder path (all supported files are indexed recursively)
• 'https://example.com/product-manual.html' — a URL
• [expandPath('./docs/'), 'https://example.com/faq.html'] — an array of any combination

The model parameter accepts either a ChatModel object (from ChatModel()) or an inline struct with type, apiKey, and modelName keys.

Here is a quick guide to the values your snippet passes into the chat model, vector store, embedding setup, and simpleRAG.

To extend your Adobe subscription using a prepaid card, follow these steps: 1. Find the redemption code beneath the scratch-off foil on the back of the prepaid card. 2. Select the appropriate link based on your product type (for example, Creative Cloud Pro, Acrobat, etc.). 3. Sign in using your Adobe ID and password. 4. Follow the onscreen instructions to complete the redemption process.

ask() is for single-turn queries: one question, one answer, no conversation memory. Use it when each query is independent and does not rely on prior context.

chat() maintains conversation context across multiple turns. Use it when follow-up questions depend on earlier answers.

You’re building a RAG bot: documents under ./docs/ are ingested into a vector store, and the app answers questions using retrieval + an LLM. chat() is used so later questions can refer to earlier turns (e.g. “What about Enterprise?” after a first answer). CHATMEMORY keeps a sliding window of recent chat so the model sees that history.

ChatModel({ ... })

This is your completion model (the thing that writes the final answer). You pass provider, model name, API key, and temperature (how random/creative vs deterministic). Same idea as configuring any other AI chat model in CF, just stored in chatModel for the RAG API.

expandPath("./docs/")

Resolves ./docs/ relative to the current template to a real server path. That folder is the corpus: whatever files RAG is allowed to read and index.

VectorStore({ ... })

The embedding store: chunks of text become vectors and get stored here for similarity search. INMEMORY means it lives in process memory (simple, but not durable across restarts).

embeddingModel nested inside is the model used to turn text into vectors. It must be consistent between ingestion (indexing) and query (searching), or dimensions/providers won’t line up.

simpleRAG(docsDir, chatModel, { ... }) simpleRAG is the high-level API: “here’s where the docs are, here’s the chat model, here’s options.”

• First arg: source path(s) to ingest from.

• Second arg: the LLM used to generate answers after retrieval.

• Third arg: extras- in this case vectorStore (where to put embeddings) and CHATMEMORY.

CHATMEMORY: { type: "messageWindowChatMemory", maxMessages: 20 }

This is what makes chat() feel like a conversation: messageWindowChatMemory keeps the last N back-and-forth messages (user + assistant), up to maxMessages.

Without something like this, each chat() call might behave more like an isolated turn (depending on implementation), so vague follow-ups (“summarize that”) wouldn’t have context.

ragBot.ingest()

Walks the source path, parses files, splits into chunks, embeds them, and writes vectors into vectorStore. You typically do this after deploy or when docs change. Until ingest has run (or completed), there’s nothing useful to retrieve.

ragBot.chat("...") three times

Each call is one user turn. Internally, something like: optional query rewrite → embed question → vector search → build prompt with retrieved chunks + recent chat → LLM → answer.

{ "aiMessage": { "text": [ "Sign in to your Adobe account.", "Navigate to the Support history page and select the case you want to modify.", "Update the case by leaving a message or uploading files up to 10 MB." ].join("\n"), "thinking": "", "toolExecutionRequests": [], "attributes": {} }, "metadata": { "id": "4", "modelName": "ChatGPT", "tokenUsage": { "inputTokenCount": 27, "outputTokenCount": 130, "totalTokenCount": 157 }, "finishReason": "STOP" } }

Chat memory is what makes chat() feel like a conversation. Without it, each chat() call behaves as an isolated turn and vague follow-ups such as "summarize that" would have no context.

messageWindowChatMemory keeps the last N back-and-forth messages (user + assistant) up to maxMessages. Configure it in the third argument to simpleRAG():

Because indexing is asynchronous, you can query the status of the index at any time. getStatistics() is a method on the RAG service object returned from simpleRAG(). It returns a struct describing the last ingestion run.

You normally call it after ingest() (or after an async ingest finishes) when you want counts, timing, and status in one place.

The returned struct contains the following fields:

Field	Description
avgSegmentsPerDocument	Average number of text segments (chunks) produced per loaded document for this ingestion run.
documentsLoaded	Count of source documents that were loaded and processed in this run.
initialized	Whether the RAG service (or its core components) finished initialization successfully.
pipelineBuilt	Whether the configured ingestion or retrieval pipeline was built without a fatal configuration error.
segmentsCreated	Total text segments created by splitting loaded documents before or independent of final store success.
segmentsFailed	Segments that could not be fully processed through the pipeline (e.g. embed or persist failures).
segmentsIngested	Segments successfully written into the embedding or vector store path for this run.
status	Overall outcome of the ingestion operation (e.g. "completed" when the job finished successfully).
timestamp	Time associated with these statistics, often epoch milliseconds when the stats snapshot was recorded.
totalDurationMs	Elapsed time for the operation in milliseconds.
totalTimeMs	Another elapsed time in milliseconds; may mirror totalDurationMs or reflect a slightly different measurement boundary.
totalTimeSec	Same or equivalent duration expressed in seconds for readability.

Ingestion reads your files, splits them into chunks, creates embeddings, and stores them in a vector store so questions can be answered from your content.

By default, synchronous ingestion (ingest()) keeps the request busy until indexing finishes. Asynchronous ingestion starts that work and returns a Future object right away. You can wait for completion when you are ready, or structure your code so other logic runs while ingestion proceeds.

Use async when:

• Ingestion may take noticeable time (large folders, many files).

• You want a clear place in code to wait (get()) or to check progress.

• You are building flows where you must not assume ingest finished until you handle the Future.

The following example shows the logical flow. Adjust struct keys (`CHATMODEL`, `ingestion`, and so on) to match your ColdFusion RAG API.

To upgrade your Adobe plan to the Creative Cloud Pro plan, follow these steps: Sign in to the Creative Cloud Pro page, select 'Buy now', and check all the apps and services included in the plan. If you are currently using a single app plan, you can select 'Switch plans' to proceed with the upgrade. Follow the onscreen instructions to complete the upgrade. Once done, you will have successfully upgraded to Creative Cloud Pro, giving you access to over 20 creative apps, including Photoshop, Illustrator, and Premiere Pro, along with additional features like Generative AI capabilities and cloud storage.

If your code uses simpleRAG() instead of agent(), the same idea applies: call ingestAsync() on the returned service if your build exposes it, then get() on the Future before ask() or chat().

Pass a third argument to simpleRAG() to tune how documents are split and how retrieval works. The following options are supported:

When you call simpleRAG() with no options struct, ColdFusion makes the following choices automatically. These defaults are designed to work well for most prose documents and development use cases.

The default in-memory vector store is not suitable for production. Documents must be re-indexed on every application restart. For production, configure a persistent vector store (Milvus, Qdrant, Chroma, or Pinecone).

These intelligent defaults follow a zero-configuration philosophy: sensible decisions are made by the system unless the developer chooses to override them. This means a developer can move from idea to working implementation with minimal setup, without needing to understand low-level concepts such as embeddings, vector databases, and orchestration pipelines.