Build a rag for customer support knowledge base that answers tickets automatically

You'll create a Retrieval-Augmented Generation (RAG) pipeline that pulls the most relevant support articles from your knowledge base, feeds them to an OpenAI LLM, and returns a ready-to-send answer to Zendesk tickets. The result is a hands-free response engine that reduces agent load while keeping answers accurate and up-to-date.

What is RAG? RAG (Retrieval-Augmented Generation) is an architecture that first retrieves relevant documents from an external source and then conditions a large language model on those passages before generating a response.

What you need

Time to build: ~8 hours for a functional prototype (2 h env setup, 3 h data ingestion, 2 h integration, 1 h testing).

Step-by-step construction

1. Prepare the development environment

Create a fresh directory and initialise a Python virtual environment:

mkdir rag-support && cd rag-support
python3 -m venv .venv
source .venv/bin/activate

This isolates dependencies and lets you run the same code locally and in Docker later.

Install the required libraries:

pip install openai langchain chromadb tqdm

Why: openai provides the embedding and completion endpoints, langchain offers high-level abstractions for retrieval, and chromadb (the Python client for Chroma) stores vectors efficiently on disk.

2. Pull your support articles from Zendesk

Export the knowledge base as Markdown or plain-text files. A quick way is to use Zendesk's API:

curl -s -H "Authorization: Bearer $ZENDESK_TOKEN" \
 "https://yoursubdomain.zendesk.com/api/v2/help_center/articles.json" \
 | jq -r '.articles[] | "\(.title)\n\(.body)"' > articles.txt

Replace $ZENDESK_TOKEN with a token that has read permission on the Help Center. The output concatenates every article into articles.txt, one article after another.

3. Chunk the articles for efficient retrieval

Long documents need to be split into manageable pieces (≈ 300 tokens) so that embeddings stay within OpenAI's token limits.

from langchain.text_splitter import RecursiveCharacterTextSplitter

with open("articles.txt", "r", encoding="utf-8") as f:
 raw = f.read()

splitter = RecursiveCharacterTextSplitter(
 chunk_size=300,
 chunk_overlap=30,
 separators=["\n\n", "\n", " "]
)
chunks = splitter.split_text(raw)
print(f"Created {len(chunks)} chunks.")

Why: Overlapping chunks preserve context across paragraph boundaries, improving retrieval relevance.

4. Generate embeddings with OpenAI

Convert each chunk into a 1536-dimensional vector using the text-embedding-ada-002 model:

import os, openai
from tqdm import tqdm

openai.api_key = os.getenv("OPENAI_API_KEY")

def embed(texts):
 # Batch up to 2048 tokens per request (OpenAI limit)
 return openai.Embedding.create(
 model="text-embedding-ada-002",
 input=texts
 )["data"]

embeddings = []
batch_size = 100
for i in tqdm(range(0, len(chunks), batch_size)):
 batch = chunks[i:i+batch_size]
 resp = embed(batch)
 embeddings.extend([r["embedding"] for r in resp])

Each embedding costs $0.0001 per 1 000 tokens, so a 10 000-article knowledge base typically stays under $5 per month on the OpenAI pay-as-you-go tier.

5. Store embeddings in a vector database

#### Option A - Local development with Chroma

import chromadb
from chromadb.utils import embedding_functions

client = chromadb.Client()
collection = client.create_collection(
 name="support-knowledge",
 embedding_function=embedding_functions.OpenAIEmbeddingFunction(
 api_key=os.getenv("OPENAI_API_KEY")
 )
)

ids = [f"doc-{i}" for i in range(len(chunks))]
collection.add(
 ids=ids,
 documents=chunks,
 embeddings=embeddings
)
print("Vectors persisted to ./chromadb")

#### Option B - Production with Pinecone (hosted)

import pinecone

pinecone.init(api_key=os.getenv("PINECONE_API_KEY"), environment="us-west1-gcp")
index = pinecone.Index("support-knowledge")
vectors = [(ids[i], embeddings[i]) for i in range(len(embeddings))]
index.upsert(vectors=vectors, namespace="support")

Why choose Pinecone? It offers sub-millisecond latency, automatic scaling, and built-in metadata filtering - critical for high-traffic support desks.

6. Build the LangChain retrieval-augmented chain

from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from langchain.vectorstores import Chroma, Pinecone
from langchain.embeddings import OpenAIEmbeddings

# Choose the backend that matches step 5
if use_chroma:
 vectorstore = Chroma(
 collection_name="support-knowledge",
 embedding_function=OpenAIEmbeddings()
 )
else:
 vectorstore = Pinecone.from_existing_index(
 index_name="support-knowledge",
 embedding=OpenAIEmbeddings(),
 namespace="support"
 )

retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
qa = RetrievalQA.from_chain_type(
 llm=OpenAI(model_name="gpt-3.5-turbo"),
 chain_type="stuff",
 retriever=retriever,
 return_source_documents=True
)

This chain fetches the four most relevant chunks, concatenates them, and prompts the LLM to answer the user's question while citing sources.

7. Expose the chain as an HTTP endpoint with n8n

1. Run n8n (Docker recommended):

 docker run -d --name n8n \
 -p 5678:5678 \
 -v ~/.n8n:/home/node/.n8n \
 n8nio/n8n
 

2. Create a workflow: - Webhook node → receives a JSON payload from Zendesk (ticket_id, question). - Execute Command node → runs a short Python script that calls qa.run(question) and returns answer and sources. - HTTP Request node → posts the answer back to the Zendesk ticket via PUT /api/v2/tickets/{ticket_id}.

1. Python script for the Execute Command node (answer.py):

 import sys, json
 from answer_chain import qa # assumes qa defined in previous step

 payload = json.loads(sys.stdin.read())
 question = payload["question"]
 resp = qa({"query": question})
 result = {
 "answer": resp["result"],
 "sources": [doc.metadata["source"] for doc in resp["source_documents"]]
 }
 print(json.dumps(result))
 

n8n pipes the incoming JSON to stdin; the script writes a JSON response to stdout which n8n captures for downstream nodes.

1. Save and activate the workflow. Its public URL (e.g., https://n8n.mycompany.com/webhook/rag-support) becomes the endpoint you register in Zendesk's Triggers UI.

8. Wire the endpoint into Zendesk

In Zendesk, create a Trigger that fires on Ticket Created with the condition Ticket is a support request. Add an Action → Notify target → HTTP target pointing at the n8n webhook URL, passing { "ticket_id": "{{ticket.id}}", "question": "{{ticket.description}}" }.

When a ticket arrives, Zendesk calls the webhook, the RAG chain returns an answer, and the workflow updates the ticket with the response.

9. Test end-to-end

Create a dummy ticket in Zendesk:

Subject: How do I reset my password?
Description: I cannot find the reset link on the login page.

After a few seconds, the ticket body should contain a concise answer such as:

To reset your password, click "Forgot password?" on the login page, enter your email, and follow the link you receive. See article "Password Reset Procedure" for screenshots.

If the answer is missing, check n8n's execution log (accessible at https://n8n.mycompany.com/executions) for any runtime errors.

!Step-by-step construction — rag for customer support knowledge base ## Where this breaks

> The most common failure is hitting OpenAI's rate limits or token quotas, which silently abort the embedding step.

For a deeper technical reference, see n8n's documentation.