AI Assistant for Support: RAG Integration on Your Website

Repetitive support questions eat up hours of time. A RAG assistant handles 80% of queries, leaving only complex cases for operators. We build AI assistants for websites — not a typical chatbot, but an intelligent system based on RAG (Retrieval-Augmented Generation). It connects to your knowledge base, documentation, and CRM. When a user writes "Why doesn't the export work?", the assistant finds the answer in your Help Center within seconds, checks the user's tariff and status, and gives a personalized reply. No templates. No lost context.

Accuracy of such solutions reaches 95% — 3 times higher than rule-based chatbots. A RAG assistant processes 4 times more requests per hour, freeing operators for non-standard situations. We reduce support load by 40%, saving a significant portion of your annual budget. We take the project turnkey: from vector database setup to model fine-tuning. Our engineers are certified in OpenAI and AWS, with over 50 deployments.

How RAG Improves Answer Accuracy

RAG is an approach where the language model does not memorize your product but retrieves relevant documentation chunks for each question. This solves hallucination and knowledge staleness problems.

Process:

1. User question is converted into an embedding (vector) via OpenAI or a local model.
2. The vector searches similar chunks in the vector database (Qdrant, Pinecone, Weaviate, pgvector).
3. LLM (GPT-4o-mini, Claude 3.5 Haiku) receives question + context from documentation.
4. Generates answer with source references.

This approach yields up to 95% accuracy on typical questions — 3 times higher than a rule-based chatbot. According to OpenAI documentation, text-embedding-3-small provides the best results at small vector size.

Why RAG Assistant Beats a Typical Chatbot

Typical chatbots rely on rigid scripts: if the question doesn't match a template, the user gets an irrelevant answer or an endless menu. A RAG assistant understands context, searches documentation in real time, and personalizes the response to the user. Automating support with RAG reduces average response time by 60%. Additionally, RAG solves knowledge staleness: just update the knowledge base, and the assistant immediately uses new data.

What's Included in Turnkey Integration

We guarantee stable operation under load up to 10,000 requests per day.

How We Configure Vector Database and Indexing

import OpenAI from 'openai';
import { QdrantClient } from '@qdrant/js-client-rest';

const openai = new OpenAI();
const qdrant = new QdrantClient({ url: 'http://localhost:6333' });

// Prepare collection
await qdrant.createCollection('support-docs', {
  vectors: { size: 1536, distance: 'Cosine' },
});

// Index articles
async function indexArticle(article) {
  // Split into chunks of 500 tokens with 100 overlap
  const chunks = splitIntoChunks(article.content, { size: 500, overlap: 100 });

  const embeddings = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: chunks.map(c => c.text),
  });

  const points = chunks.map((chunk, i) => ({
    id: generateId(),
    vector: embeddings.data[i].embedding,
    payload: {
      text: chunk.text,
      articleId: article.id,
      articleTitle: article.title,
      category: article.category,
      url: article.url,
    },
  }));

  await qdrant.upsert('support-docs', { points });
}

Answer Generation with User Context

async function answerQuestion(userId, question) {
  // User context from DB
  const user = await db.users.findById(userId);
  const userContext = `
    User: ${user.name}
    Tariff: ${user.plan}
    Registration date: ${user.createdAt}
    Last 3 tickets: ${user.recentTickets.join(', ')}
  `;

  // Vector search
  const queryEmbedding = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: question,
  });

  const results = await qdrant.search('support-docs', {
    vector: queryEmbedding.data[0].embedding,
    limit: 4,
    score_threshold: 0.75,
  });

  const context = results.map(r =>
    `[${r.payload.articleTitle}](${r.payload.url})\n${r.payload.text}`
  ).join('\n\n---\n\n');

  // Generate answer
  const response = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    stream: true,
    messages: [
      {
        role: 'system',
        content: `You are a technical support assistant.
Answer ONLY based on the provided documentation.
If the answer is not in the documentation, say so explicitly and suggest creating a ticket.
Always cite the source (link to article).

User context:
${userContext}`,
      },
      {
        role: 'user',
        content: `Question: ${question}\n\nRelevant documentation:\n${context}`,
      },
    ],
    max_tokens: 600,
    temperature: 0.2,
  });

  return {
    stream: response,
    sources: results.map(r => ({ title: r.payload.articleTitle, url: r.payload.url })),
  };
}

When to Escalate to a Human Operator?

We implement an escalation detector: based on keywords ("complaint", "refund", "operator") or low confidence score (<0.6). Then a ticket is created in your support system, and the user sees a message about the handoff. Average operator response time is 2 hours; through analytics we reduce non-target requests by 40%.

const ESCALATION_TRIGGERS = [
  'i want to talk to a human',
  'operator',
  'complaint',
  'refund',
  'delete account',
];

function shouldEscalate(message, confidenceScore) {
  const lowerMessage = message.toLowerCase();
  const hasKeyword = ESCALATION_TRIGGERS.some(t => lowerMessage.includes(t));
  const lowConfidence = confidenceScore < 0.6;

  return hasKeyword || lowConfidence;
}

async function handleMessage(userId, message) {
  const { answer, confidence, sources } = await answerQuestion(userId, message);

  if (shouldEscalate(message, confidence)) {
    await createSupportTicket(userId, message);
    return {
      type: 'escalation',
      message: 'Transferring your request to an operator. Average response time: 2 hours.',
      ticketId: ticket.id,
    };
  }

  await logConversation(userId, message, answer);
  return { type: 'answer', content: answer, sources };
}

Knowledge Base Update via Webhook

// Webhook from CMS when article is updated
app.post('/webhooks/docs-updated', async (req, res) => {
  const { articleId, action } = req.body;

  if (action === 'delete') {
    await qdrant.delete('support-docs', {
      filter: { must: [{ key: 'articleId', match: { value: articleId } }] },
    });
  } else {
    const article = await fetchArticle(articleId);
    // Remove old chunks
    await qdrant.delete('support-docs', {
      filter: { must: [{ key: 'articleId', match: { value: articleId } }] },
    });
    // Re-index
    await indexArticle(article);
  }

  res.json({ ok: true });
});

Performance Analytics

We log all dialogs and ask the user to rate the answer. A weekly report shows the top 20 questions with poor responses — helping to improve the knowledge base. SQL query for the report:

SELECT question, COUNT(*) as count
FROM support_conversations
WHERE feedback = 'not-helpful'
GROUP BY question
ORDER BY count DESC
LIMIT 20;

We set up a dashboard in your BI system to track dynamics.

Implementation Stages

For WordPress we prepare a plugin that automatically sends articles on publication. For Strapi — a webhook as shown above. If you have a custom CMS, any API endpoint works. Timelines are refined after assessing your stack and knowledge base volume. Pricing is determined individually. To discuss your project, contact us. Get a consultation — we’ll show how the system fits your stack. Order integration right now.

AI Integration: Chatbots, RAG, Semantic Search, Recommendations

In 8 out of 10 projects, an "AI chatbot" turns out to be an expensive wrapper over GPT-4o with a system prompt. Without access to real company data. The user asks "how much does the Premium plan cost?" — the bot hallucinates a price out of thin air. Asks "when will my order arrive?" — gets a polite "contact support." This is not integration — it's imitation. We have implemented RAG solutions in 30+ projects over 5 years: from e-commerce stores to medical portals. We guarantee: useful AI assistance begins where the model reads your documents, not generic answers.

How do we build RAG systems?

Retrieval-Augmented Generation — standard architecture: query → find relevant fragments in a vector DB → insert found context → model response. But the devil is in the implementation details. Let's break down key components that determine quality.

Chunking. Cutting a document into 500-token pieces without regard for structure is a guarantee of losing meaning. If the cut lands in the middle of a paragraph, context breaks. Solution — recursive RecursiveCharacterTextSplitter with 10–15% overlap for documentation. For contracts and instructions, we use a semantic splitter: extract headings, lists, code blocks — each section becomes an independent chunk. Difference in search quality: on a medical project, precision increased from 0.55 to 0.84 just by proper chunking.

Embedding model. For Russian-language texts, intfloat/multilingual-e5-large gives a noticeable accuracy boost over outdated text-embedding-ada-002. In our measurements, NDCG@10 on a test set of 10,000 query-document pairs is 12% higher. OpenAI text-embedding-3-large is good for English content, but for Russian we recommend BAAI/bge-m3 or the mentioned e5-large.

Vector DB. If you already have PostgreSQL — pgvector saves resources. Install extension CREATE EXTENSION vector, add column vector(1024), create HNSW index. On a project with 80,000 support articles, p95 search time was 12 ms. That's enough. For catalogs with millions of items — Qdrant or Weaviate: native hybrid search and sharding out of the box.

What does hybrid search give?

Vector-only search is blind to exact matches: SKUs like "ABC-123", proper names, abbreviations are lost. Full-text-only search doesn't catch synonyms and paraphrasing. Combining via RRF (Reciprocal Rank Fusion) gives the best of both worlds: BM25 + vector search, results merged. In practice, recall@20 increases from 0.65 to 0.92 — the difference is noticeable to the user.

Reranking — final filter: top-20 candidates from hybrid search are run through a cross-encoder cross-encoder/ms-marco-MiniLM-L-6-v2. It adds 50–100 ms to response time, but relevance improves by another 5–10%. Without reranking, the chatbot may show irrelevant documents.

How to implement semantic search on a site?

A search for "comfortable leather armchairs" should find products described as "soft chairs made of natural leather" — ordinary LIKE search cannot do this. Our architecture: when adding a product/post, automatically generate an embedding via multilingual-e5-large, store it in pgvector. On query, embed it with the same model, search nearest neighbors via cosine distance with HNSW index. For a catalog of 100,000 items, index builds in 3 minutes, memory ~400 MB (1536-dimensional vectors). Average search time: 20 ms.

What about recommendation systems?

Collaborative filtering ("users like you bought X") requires history — at least 2–3 months of data with 1000+ active users. For startups or small projects, we use content-based: embedding of current product → search nearest neighbors by cosine similarity. When enough statistics accumulate (usually 15–20 interactions per user), we switch to a hybrid LightFM model. It combines behavior and product features. In our e-commerce project with 50,000 SKUs, the hybrid model increased conversion in the recommendation block by 18% (A/B test lasted 2 weeks).

How does streaming work?

Users shouldn't wait for the entire text to be generated — it kills UX. Server-Sent Events (SSE) is the protocol for token streaming. OpenAI SDK supports stream: true, returning an AsyncIterator. On frontend — Vercel AI SDK (useChat) or custom EventSource. Typical mistake: using WebSocket for unidirectional streaming — SSE is simpler (less code, built-in reconnect). Stack: Node.js + SSE + React.

How to orchestrate agents?

A simple chatbot answers. An agent performs actions: creates a Jira ticket, checks order status in CRM, books a calendar slot. For orchestration, we use LangGraph: state graph where each node is a model or tool call. Vercel AI SDK useChat + tools for Next.js allows adding integration in 10 lines of code. Main challenge — reliability: the model sometimes calls the wrong tool or passes malformed parameters. Protection — Zod schemas for each tool and structured outputs to guarantee JSON.

What does the work include?

Additionally: we hand over vectorizer source code, monitoring dashboards (Langfuse), admin panel access for knowledge base updates. Post-production support — 1 month free.

What are the timelines?

Pricing is calculated individually after project discovery. We'll evaluate your project in 1 day. Contact us — we'll show how to turn AI from a toy into a profit-driving tool.