In Confluence, 1200 pages, fifty authors—nobody remembers where the VPN instruction is. Employees spend an average of 20 minutes searching, and often just ask in chats. Keyword search returns a list of articles without context. RAG changes this: you ask a question and get an answer with citations in 10 seconds. We've been building such systems for over 5 years and deployed 15+ projects. Our proven methodology and guarantee of at least 80% accuracy ensure reliable performance. Average savings were $1,500 per month, with a 4-month payback. For one client, savings reached $15,000 per year by reducing engineer search time. Typical project cost ranges from $5,000 to $15,000, fully recouped within months.
How semantic search works
Our AI document search solution uses LlamaIndex with Qdrant as the vector store (HNSW index for ANN search, cosine similarity metric) and HuggingFace embedding model. Documents are split into chunks, vectorized, and stored in a vector DB. On query, semantically close chunks are retrieved via approximate nearest neighbor (ANN), reranked by a cross-encoder model, and an LLM generates the final answer with citations. For Russian-English bases, we use multilingual-e5-large (1024d)—it outperforms BGE-small by 1.15x in recall. Key code snippet:
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.node_parser import SentenceSplitter
from llama_index.core.retrievers import VectorIndexRetriever
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.postprocessor import SentenceTransformerRerank
from llama_index.vector_stores.qdrant import QdrantVectorStore
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
import qdrant_client
embed_model = HuggingFaceEmbedding(
model_name="intfloat/multilingual-e5-large",
embed_batch_size=32
)
splitter = SentenceSplitter(
chunk_size=512,
chunk_overlap=64,
paragraph_separator="\n\n"
)
reranker = SentenceTransformerRerank(
model="cross-encoder/ms-marco-MiniLM-L-6-v2",
top_n=5
)
client = qdrant_client.QdrantClient(url="http://localhost:6333")
vector_store = QdrantVectorStore(client=client, collection_name="kb_docs")
index = VectorStoreIndex.from_vector_store(
vector_store=vector_store,
embed_model=embed_model
)
query_engine = RetrieverQueryEngine(
retriever=VectorIndexRetriever(index=index, similarity_top_k=15),
node_postprocessors=[reranker],
)
Why parent-child chunking is necessary
Documentation is hierarchical: section, subsection, paragraph. Naive chunking at 512 tokens cuts logical blocks. Solution—parent-child chunking: small chunks for retrieval, large ones for context. This improves faithfulness by 1.12x and relevance by 1.18x over flat chunking.
| Parameter | Flat chunking | Parent-child chunking |
|---|---|---|
| Faithfulness (RAGAS) | 0.68 | 0.76 |
| Relevance (RAGAS) | 0.72 | 0.85 |
How to set up incremental updates
Key steps to configure a RAG pipeline for intelligent search
- Collect all sources (Confluence, Notion, Google Docs) for knowledge base search.
- Choose an embedding model (multilingual-e5-large for Russian+English) as your AI document search model.
- Set up parent-child chunking with parent=1024 tokens, child=256.
- Deploy a vector DB (Qdrant or pgvector) with HNSW index.
- Implement an automatic indexing pipeline with incremental update through API.
- Connect a reranker (cross-encoder) to improve accuracy.
- Integrate an LLM (GPT-4o or Claude) for answer generation, creating a documentation chatbot.
class DocumentationIndexer:
def __init__(self, confluence_client, vector_store):
self.confluence = confluence_client
self.index = vector_store
self.last_indexed = {}
async def incremental_update(self):
all_pages = self.confluence.get_all_pages(space_key="KB")
for page in all_pages:
page_id = page["id"]
modified = page["version"]["when"]
if self.last_indexed.get(page_id) == modified:
continue
self.index.delete(filter={"page_id": page_id})
content = self.confluence.get_page_body(page_id)
nodes = self._parse_and_chunk(content, page)
self.index.add(nodes)
self.last_indexed[page_id] = modified
return {"updated": len([p for p in all_pages if self.last_indexed.get(p["id"]) != p["version"]["when"]])}
Incremental updates run every hour, ensuring freshness without re-indexing the entire corpus.
Process
| Stage | Duration | What we do | Result |
|---|---|---|---|
| Analysis | 1–2 days | Analyze documentation structure, document types, query frequency | Technical specification and prototype on 10–20 documents |
| Design | 2–3 days | Select embedding model, vector database, chunking scheme | Solution architecture document |
| Implementation | 1–4 weeks | Develop automatic indexing pipeline, configure retriever and LLM, integrate with Confluence AI and Notion AI via API, add documentation chatbot interface | Working system on test set |
| Testing | 3–5 days | Evaluate using RAGAS (faithfulness, relevance, precision), conduct A/B test | Report with metrics and recommendations |
| Deployment | 2–3 days | Deploy on client infrastructure, set up CI/CD | Production environment, admin documentation |
What's included
- Solution architecture document with model and vector database choices.
- Automatic indexing pipeline with parent-child chunking and incremental updates.
- Integration with Confluence, Notion, or Google Docs via API for AI document search.
- Slack bot or web interface for queries with source citations (documentation chatbot).
- Admin panel for monitoring queries and metrics (RAGAS faithfulness, relevance).
- Admin documentation and team training (2 hours).
- Support for 1 month after launch.
- Guaranteed accuracy of at least 80% on internal documentation.
Typical mistakes
- Ignoring document hierarchy. Parent-child chunking is mandatory—otherwise you lose up to 18% relevance.
- Infrequent index updates. Set up an incremental pipeline every hour.
- Choosing a weak embedding model. For Russian-English documentation, multilingual-e5-large (1024d) or BGE-M3 is the minimum. BGE-small loses 15% recall.
- No reranker. Without cross-encoder, top-3 accuracy drops by 10–20%.
- Neglecting security. Set up prompt injection filtering and query auditing.
Case: IT company, 200 employees, 1200 articles. Average response time 1.4 sec, accuracy 82%. Repeated questions in #general dropped by 43% in the first month. Project paid back in 4 months—average savings $12,000 per year.
Contact us to evaluate your project. Get a consultation on deploying RAG search on your data. Request demo access to a ready system on a test document set. Our team guarantees system performance and reliability based on 5+ years of proven experience.