Build RAG Chatbot with Haystack, Haystack In-memory store, OpenAI GPT-4o mini, and BAAI bge-large-en-v1.5
Introduction to RAG
Retrieval-Augmented Generation (RAG) is a game-changer for GenAI applications, especially in conversational AI. It combines the power of pre-trained large language models (LLMs) like OpenAI’s GPT with external knowledge sources stored in vector databases such as Milvus and Zilliz Cloud, allowing for more accurate, contextually relevant, and up-to-date response generation. A RAG pipeline usually consists of four basic components: a vector database, an embedding model, an LLM, and a framework.
Key Components We'll Use for This RAG Chatbot
This tutorial shows you how to build a simple RAG chatbot in Python using the following components:
- Haystack: An open-source Python framework designed for building production-ready NLP applications, particularly question answering and semantic search systems. Haystack excels at retrieving information from large document collections through its modular architecture that combines retrieval and reader components. Ideal for developers creating search applications, chatbots, and knowledge management systems that require efficient document processing and accurate information extraction from unstructured text.
- Haystack in-memory store: a very simple, in-memory document store with no extra services or dependencies. It is great for experimenting with Haystack, and we do not recommend using it for production. If you want a much more scalable solution for your apps or even enterprise projects, we recommend using Zilliz Cloud, which is a fully managed vector database service built on the open-source Milvusand offers a free tier supporting up to 1 million vectors.)
- OpenAI GPT-4o mini: A streamlined, cost-efficient variant of GPT-4, optimized for scalable AI applications. It balances high performance with reduced computational demands, offering fast response times and lower costs. Ideal for real-time chatbots, content generation, and integration into resource-constrained environments like mobile apps or high-volume transactional systems.
- BAAI bge-large-en-v1.5: A dense embedding model optimized for semantic retrieval, excelling in capturing nuanced text semantics for tasks like retrieval-augmented generation (RAG), semantic search, and clustering. Its strengths include high accuracy across diverse domains, robust handling of complex queries, and efficient scalability. Ideal for enterprise search engines, recommendation systems, and knowledge-intensive NLP applications requiring precise contextual understanding.
By the end of this tutorial, you’ll have a functional chatbot capable of answering questions based on a custom knowledge base.
Note: Since we may use proprietary models in our tutorials, make sure you have the required API key beforehand.
Step 1: Install and Set Up Haystack
import os
import requests
from haystack import Pipeline
from haystack.components.converters import MarkdownToDocument
from haystack.components.preprocessors import DocumentSplitter
from haystack.components.writers import DocumentWriter
Step 2: Install and Set Up OpenAI GPT-4o mini
To use OpenAI models, you need to get an OpenAI API key. The Haystack integration with OpenAI models uses an OPENAI_API_KEY
environment variable by default. Otherwise, you can pass an API key at initialization with api_key
:
generator = OpenAIGenerator(api_key=Secret.from_token("<your-api-key>"), model="gpt-4o-mini")
Then, the generator component needs a prompt to operate, but you can pass any text generation parameters valid for the openai.ChatCompletion.create
method directly to this component using the generation_kwargs
parameter, both at initialization and to run()
method. For more details on the parameters supported by the OpenAI API, refer to the OpenAI documentation.
Now let's install and set up OpenAI models.
from haystack.components.generators import OpenAIGenerator
generator = OpenAIGenerator(model="gpt-4o-mini", api_key=Secret.from_token("<your-api-key>"))
Step 3: Install and Set Up BAAI bge-large-en-v1.5
from haystack import Document
from haystack.components.embedders import SentenceTransformersDocumentEmbedder
from haystack.components.embedders import SentenceTransformersTextEmbedder
doc_embedder = SentenceTransformersDocumentEmbedder(model="BAAI/bge-large-en-v1.5")
doc_embedder.warm_up()
text_embedder = SentenceTransformersTextEmbedder(model="BAAI/bge-large-en-v1.5")
text_embedder.warm_up()
Step 4: Install and Set Up Haystack In-memory store
from haystack.document_stores.in_memory import InMemoryDocumentStore
from haystack.components.retrievers import InMemoryEmbeddingRetriever
document_store = InMemoryDocumentStore()
retriever=InMemoryEmbeddingRetriever(document_store=document_store))
Step 5: Build a RAG Chatbot
Now that you’ve set up all components, let’s start to build a simple chatbot. We’ll use the Milvus introduction doc as a private knowledge base. You can replace it your own dataset to customize your RAG chatbot.
url = 'https://raw.githubusercontent.com/milvus-io/milvus-docs/refs/heads/v2.5.x/site/en/about/overview.md'
example_file = 'example_file.md'
response = requests.get(url)
with open(example_file, 'wb') as f:
f.write(response.content)
file_paths = [example_file] # You can replace it with your own file paths.
indexing_pipeline = Pipeline()
indexing_pipeline.add_component("converter", MarkdownToDocument())
indexing_pipeline.add_component("splitter", DocumentSplitter(split_by="sentence", split_length=2))
indexing_pipeline.add_component("embedder", document_embedder)
indexing_pipeline.add_component("writer", DocumentWriter(document_store))
indexing_pipeline.connect("converter", "splitter")
indexing_pipeline.connect("splitter", "embedder")
indexing_pipeline.connect("embedder", "writer")
indexing_pipeline.run({"converter": {"sources": file_paths}})
# print("Number of documents:", document_store.count_documents())
question = "What is Milvus?" # You can replace it with your own question.
retrieval_pipeline = Pipeline()
retrieval_pipeline.add_component("embedder", text_embedder)
retrieval_pipeline.add_component("retriever", retriever)
retrieval_pipeline.connect("embedder", "retriever")
retrieval_results = retrieval_pipeline.run({"embedder": {"text": question}})
# for doc in retrieval_results["retriever"]["documents"]:
# print(doc.content)
# print("-" * 10)
from haystack.utils import Secret
from haystack.components.builders import PromptBuilder
retriever=InMemoryEmbeddingRetriever(document_store=document_store)
text_embedder = SentenceTransformersTextEmbedder(model="BAAI/bge-large-en-v1.5")
text_embedder.warm_up()
prompt_template = """Answer the following query based on the provided context. If the context does
not include an answer, reply with 'I don't know'.\n
Query: {{query}}
Documents:
{% for doc in documents %}
{{ doc.content }}
{% endfor %}
Answer:
"""
rag_pipeline = Pipeline()
rag_pipeline.add_component("text_embedder", text_embedder)
rag_pipeline.add_component("retriever", retriever)
rag_pipeline.add_component("prompt_builder", PromptBuilder(template=prompt_template))
rag_pipeline.add_component("generator", generator)
rag_pipeline.connect("text_embedder.embedding", "retriever.query_embedding")
rag_pipeline.connect("retriever.documents", "prompt_builder.documents")
rag_pipeline.connect("prompt_builder", "generator")
results = rag_pipeline.run({"text_embedder": {"text": question}, "prompt_builder": {"query": question},})
print('RAG answer:\n', results["generator"]["replies"][0])
Optimization Tips
As you build your RAG system, optimization is key to ensuring peak performance and efficiency. While setting up the components is an essential first step, fine-tuning each one will help you create a solution that works even better and scales seamlessly. In this section, we’ll share some practical tips for optimizing all these components, giving you the edge to build smarter, faster, and more responsive RAG applications.
Haystack optimization tips
To optimize Haystack in a RAG setup, ensure you use an efficient retriever like FAISS or Milvus for scalable and fast similarity searches. Fine-tune your document store settings, such as indexing strategies and storage backends, to balance speed and accuracy. Use batch processing for embedding generation to reduce latency and optimize API calls. Leverage Haystack's pipeline caching to avoid redundant computations, especially for frequently queried documents. Tune your reader model by selecting a lightweight yet accurate transformer-based model like DistilBERT to speed up response times. Implement query rewriting or filtering techniques to enhance retrieval quality, ensuring the most relevant documents are retrieved for generation. Finally, monitor system performance with Haystack’s built-in evaluation tools to iteratively refine your setup based on real-world query performance.
Haystack in-memory store optimization tips
Haystack in-memory store is just a very simple, in-memory document store with no extra services or dependencies. We recommend that you just experiment it with RAG pipeline within your Haystack framework, and we do not recommend using it for production. If you want a much more scalable solution for your apps or even enterprise projects, we recommend using Zilliz Cloud, which is a fully managed vector database service built on the open-source Milvusand offers a free tier supporting up to 1 million vectors
OpenAI GPT-4o Mini optimization tips
To optimize the OpenAI GPT-4o Mini in a RAG setup, ensure concise input formatting by truncating or summarizing retrieved documents to stay within token limits. Use precise query phrasing to improve retrieval relevance, and filter redundant context to reduce noise. Leverage temperature and max_tokens parameters to balance creativity and focus. Cache frequent queries to minimize API calls and latency. Regularly validate outputs against ground truth to refine prompts and retrieval logic. Prioritize structured templates for consistent responses and implement error handling for rate limits or timeouts.
BAAI bge-large-en-v1.5 optimization tips
To optimize BAAI bge-large-en-v1.5 in RAG, ensure input text is clean and preprocessed (remove noise, truncate to 512 tokens). Use the model’s instruction prefix ("Represent this sentence for retrieval: "
) for query embeddings to align with its training. Batch embedding generation for efficiency, and normalize outputs before similarity comparisons. Fine-tune on domain-specific data if retrieval accuracy lags. Use FAISS or HNSW for fast vector search, and quantize embeddings to reduce memory. Regularly evaluate recall@k to balance speed and relevance. Leverage GPU acceleration and optimize temperature/sampling for generation coherence.
By implementing these tips across your components, you'll be able to enhance the performance and functionality of your RAG system, ensuring it’s optimized for both speed and accuracy. Keep testing, iterating, and refining your setup to stay ahead in the ever-evolving world of AI development.
RAG Cost Calculator: A Free Tool to Calculate Your Cost in Seconds
Estimating the cost of a Retrieval-Augmented Generation (RAG) pipeline involves analyzing expenses across vector storage, compute resources, and API usage. Key cost drivers include vector database queries, embedding generation, and LLM inference.
RAG Cost Calculator is a free tool that quickly estimates the cost of building a RAG pipeline, including chunking, embedding, vector storage/search, and LLM generation. It also helps you identify cost-saving opportunities and achieve up to 10x cost reduction on vector databases with the serverless option.
Calculate your RAG cost
What Have You Learned?
By diving into this tutorial, you’ve discovered how to weave together cutting-edge tools to create a powerful RAG system that breathes life into AI applications! You learned how Haystack, the flexible framework, acts as the backbone, orchestrating the entire pipeline—tying data ingestion, retrieval, and generation into a seamless workflow. The Haystack In-Memory Store became your trusty vector database, lightning-fast for prototyping, storing embeddings generated by the BAAI bge-large-en-v1.5 model, which transformed text into rich numerical representations. Then, OpenAI’s GPT-4o mini stepped in as the creative genius, synthesizing retrieved context into human-like answers. Together, these tools form a powerhouse: embeddings unlock semantic search, the database serves relevant snippets, and the LLM crafts precise, context-aware responses. You saw firsthand how each component’s unique strength—speed, accuracy, adaptability—combines to solve real-world problems, like answering complex questions or summarizing documents with nuance.
But wait—there’s more! You also picked up pro tips for optimizing your RAG pipeline, like tweaking chunk sizes for better retrieval or balancing cost and performance. The tutorial’s free RAG cost calculator even gave you superpowers to estimate expenses upfront, so you can experiment fearlessly. Imagine what’s next: customizing this system for your own data, fine-tuning models, or scaling it to serve thousands. The sky’s the limit! You’ve got the tools, the know-how, and the spark to turn ideas into intelligent applications. So why wait? Dive in, tweak that code, and watch your RAG creations come alive. The future of AI is yours to shape—build boldly, optimize cleverly, and let your innovations inspire the world. Let’s go! 🚀
Further Resources
🌟 In addition to this RAG tutorial, unleash your full potential with these incredible resources to level up your RAG skills.
- How to Build a Multimodal RAG | Documentation
- How to Enhance the Performance of Your RAG Pipeline
- Graph RAG with Milvus | Documentation
- How to Evaluate RAG Applications - Zilliz Learn
- Generative AI Resource Hub | Zilliz
We'd Love to Hear What You Think!
We’d love to hear your thoughts! 🌟 Leave your questions or comments below or join our vibrant Milvus Discord community to share your experiences, ask questions, or connect with thousands of AI enthusiasts. Your journey matters to us!
If you like this tutorial, show your support by giving our Milvus GitHub repo a star ⭐—it means the world to us and inspires us to keep creating! 💖
- Introduction to RAG
- Key Components We'll Use for This RAG Chatbot
- Step 1: Install and Set Up Haystack
- Step 2: Install and Set Up OpenAI GPT-4o mini
- Step 3: Install and Set Up BAAI bge-large-en-v1.5
- Step 4: Install and Set Up Haystack In-memory store
- Step 5: Build a RAG Chatbot
- Optimization Tips
- RAG Cost Calculator: A Free Tool to Calculate Your Cost in Seconds
- What Have You Learned?
- Further Resources
- We'd Love to Hear What You Think!
Content
Vector Database at Scale
Zilliz Cloud is a fully-managed vector database built for scale, perfect for your RAG apps.
Try Zilliz Cloud for Free