Build AI that searches your documents and answers questions. Use when building a knowledge base, help center Q&A, chatting with documents, answering questions from a database, search-and-answer over internal docs, customer support bot, or FAQ system. Also use when embedding search loses critical context, retrieval returns irrelevant results, the right document is buried deep in search results, RAG pipeline tutorial, semantic search over documents, or vector database search quality.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Build AI that searches your documents and answers questions. Use when building a knowledge base, help center Q&A, chatting with documents, answering questions from a database, search-and-answer over internal docs, customer support bot, or FAQ system. Also use when embedding search loses critical context, retrieval returns irrelevant results, the right document is buried deep in search results, RAG pipeline tutorial, semantic search over documents, or vector database search quality.
Build AI-Powered Document Search
Guide the user through building an AI that searches documents and answers questions accurately. Uses DSPy's RAG (retrieval-augmented generation) pattern — retrieve relevant passages, then generate an answer grounded in them.
Step 0: Load your data
If you have documents in files, databases, or SaaS tools, use LangChain's document loaders to get them into a standard format before building your search pipeline.
LangChain document loaders
from langchain_community.document_loaders import (
PyPDFLoader,
TextLoader,
CSVLoader,
WebBaseLoader,
DirectoryLoader,
NotionDBLoader,
JSONLoader,
)
# PDF files
docs = PyPDFLoader("report.pdf").load()
# All text files in a directory
docs = DirectoryLoader("./docs/", glob="**/*.txt", loader_cls=TextLoader).load()
# Web pages
docs = WebBaseLoader("https://example.com/help").load()
# CSV
docs = CSVLoader("data.csv", source_column="url").load()
# JSON
docs = JSONLoader("data.json", jq_schema=, content_key=).load()
".records[]"
"text"
Text splitting
Split loaded documents into chunks sized for embedding and retrieval:
from langchain_text_splitters import RecursiveCharacterTextSplitter
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(docs)
# Each chunk has .page_content (text) and .metadata (source info)
Splitter
Best for
RecursiveCharacterTextSplitter
General-purpose (recommended default)
MarkdownHeaderTextSplitter
Markdown docs — splits by heading
TokenTextSplitter
When you need strict token budgets
Vector store setup with LangChain
from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(model="text-embedding-3-small") # or HuggingFaceEmbeddings, etc.
vectorstore = Chroma.from_documents(chunks, embeddings, persist_directory="./chroma_db")
# Use as a retriever
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
results = retriever.invoke("How do refunds work?")
Other stores follow the same pattern: Pinecone.from_documents(...), FAISS.from_documents(...).
Once your data is loaded and chunked, wire it into a DSPy retriever (Step 3 below) or use ChromaDB directly. For the full LangChain/LangGraph API, see the LangChain docs.
Step 1: Understand the setup
Ask the user:
What documents are you searching? (PDFs, web pages, database, help articles, etc.)
What kind of questions will users ask? (factual lookups, how-to questions, multi-step research?)
Do you have a search backend already? (Elasticsearch, Pinecone, ChromaDB, pgvector, etc.)
Do questions need info from multiple documents? (simple lookup vs. combining info)
Step 2: Build the search-and-answer pipeline
Basic: search then answer
import dspy
lm = dspy.LM("openai/gpt-4o-mini") # or "anthropic/claude-sonnet-4-5-20250929", etc.
dspy.configure(lm=lm)
classAnswerFromDocs(dspy.Signature):
"""Answer the question based on the given context."""
context: list[str] = dspy.InputField(desc="Relevant passages from the knowledge base")
question: str = dspy.InputField(desc="User's question")
answer: str = dspy.OutputField(desc="Answer grounded in the context")
classDocSearch(dspy.Module):
def__init__(self, num_passages=3):
self.retrieve = dspy.Retrieve(k=num_passages)
self.answer = dspy.ChainOfThought(AnswerFromDocs)
defforward(self, question):
context = self.retrieve(question).passages
returnself.answer(context=context, question=question)
Configure the search backend
DSPy supports multiple search backends. Set up via dspy.configure:
# ColBERTv2 (hosted)
colbert = dspy.ColBERTv2(url="http://your-server:port/endpoint")
dspy.configure(lm=lm, rm=colbert)
# Or wrap your own search (Elasticsearch, Pinecone, pgvector, etc.)classMySearchBackend(dspy.Retrieve):
defforward(self, query, k=None):
k = k orself.k
# Your search logic here
results = your_search_function(query, top_k=k)
return dspy.Prediction(passages=[r["text"] for r in results])
Step 3: Set up a vector store
If you do not have a search backend yet, set one up. For prototyping, use dspy.Embeddings (built-in, no external DB needed) or ChromaDB:
DSPy built-in retriever (simplest option)
embedder = dspy.Embedder("openai/text-embedding-3-small") # or any supported model
retriever = dspy.Embeddings(corpus=corpus_texts, embedder=embedder, k=5)
# Uses FAISS for large corpora (>20K docs), brute-force for smaller ones# Use retriever("query") to search — returns dspy.Prediction(passages=..., indices=...)
dspy.configure(lm=lm, rm=retriever)
Split documents into passages before adding them to the vector store. Sentence-based chunking works well for most use cases:
import re
defchunk_text(text, max_sentences=5):
"""Split text into chunks of N sentences."""
sentences = re.split(r'(?<=[.!?])\s+', text.strip())
chunks = []
for i inrange(0, len(sentences), max_sentences):
chunk = " ".join(sentences[i:i + max_sentences])
if chunk:
chunks.append(chunk)
return chunks
# Load and chunk your documentsfor doc in documents:
chunks = chunk_text(doc["text"])
collection.add(
documents=chunks,
ids=[f"{doc['id']}_chunk_{i}"for i inrange(len(chunks))],
metadatas=[{"source": doc["source"]}] * len(chunks),
)
Custom embeddings
ChromaDB uses its default embedding function, but you can swap in others:
classGenerateSearchQuery(dspy.Signature):
"""Generate a search query to find missing information."""
context: list[str] = dspy.InputField(desc="Information gathered so far")
question: str = dspy.InputField(desc="The question to answer")
query: str = dspy.OutputField(desc="Search query to find missing information")
classMultiStepSearch(dspy.Module):
def__init__(self, num_passages=3, num_searches=2):
self.retrieve = dspy.Retrieve(k=num_passages)
self.generate_query = [dspy.ChainOfThought(GenerateSearchQuery) for _ inrange(num_searches)]
self.answer = dspy.ChainOfThought(AnswerFromDocs)
defforward(self, question):
context = []
for hop inself.generate_query:
query = hop(context=context, question=question).query
passages = self.retrieve(query).passages
context = deduplicate(context + passages)
returnself.answer(context=context, question=question)
defdeduplicate(passages):
seen = set()
result = []
for p in passages:
if p notin seen:
seen.add(p)
result.append(p)
return result
Step 5: Test the quality
defsearch_metric(example, prediction, trace=None):
# Exact match (simple)return prediction.answer == example.answer
# Or use an AI judge for open-ended answersclassJudgeAnswer(dspy.Signature):
"""Is the predicted answer correct given the expected answer?"""
question: str = dspy.InputField()
gold_answer: str = dspy.InputField()
predicted_answer: str = dspy.InputField()
is_correct: bool = dspy.OutputField()
defjudge_metric(example, prediction, trace=None):
judge = dspy.Predict(JudgeAnswer)
result = judge(
question=example.question,
gold_answer=example.answer,
predicted_answer=prediction.answer,
)
return result.is_correct
Step 6: Improve accuracy
optimizer = dspy.BootstrapFewShot(metric=search_metric, max_bootstrapped_demos=4)
optimized = optimizer.compile(DocSearch(), trainset=trainset)
# Typical improvement: 45-60% exact match -> 65-80% after optimization# For further gains, upgrade to MIPROv2:# optimizer = dspy.MIPROv2(metric=search_metric, auto="medium")
When NOT to use RAG
Data fits in context — if all your documents fit within the LM context window (under ~100K tokens), pass them directly as context instead of building a retrieval pipeline. RAG adds complexity for no benefit.
Questions are always about the same document — if every query targets one known document, skip retrieval and just include it.
You need exact keyword search — if users search by ID, SKU, or exact phrases, a database query or full-text search (Elasticsearch, Postgres tsvector) outperforms embedding search. Use RAG only when queries are semantic.
Real-time data — if the answer changes every minute (stock prices, live dashboards), a retrieval index will be stale. Query the source directly.
Key patterns
Prefer ChainOfThought for the answer step — reasoning typically helps ground answers in the documents. Use Predict if latency matters more than accuracy
Include context in the signature so the AI knows to use the retrieved passages
Multi-step search for complex questions — if one search is not enough, chain search queries
Use dspy.Refine to ensure answers actually cite the documents by scoring citation presence in a reward function
Separate search from answer generation — optimize each independently
Consider joint prompt + retrieval optimization — the GEPA paper (arxiv 2507.19457) shows a RAG adapter that jointly optimizes prompts and retrieval strategy for multiplicative gains. See /dspy-gepa for details
Consider dspy.Embeddings as a built-in retriever — it handles embedding, FAISS indexing, and search in one class without needing a separate vector store (see reference.md for API details)
Gotchas
Chunk size matters more than retriever choice — most RAG failures trace to bad chunking, not bad embeddings. Start with 512 tokens with 50-token overlap and tune from there.
Do not skip the reranking step — embedding similarity retrieves candidates; a reranker (or LM-based reranker) filters them. Without reranking, irrelevant passages dilute the context.
k=3 is not always right — the default k (number of retrieved passages) is a critical hyperparameter. Too few and you miss relevant context; too many and you overwhelm the LM. Tune it against your dev set.
Test with questions that require combining information — single-hop retrieval fails when the answer spans multiple chunks. Use dspy.ChainOfThought with multi-step retrieval for these cases.
Embedding models and chunk sizes must match at index and query time — if you re-chunk or switch embedding models, you must rebuild the vector index. Stale indexes silently return bad results.
Cross-references
Install any skill: npx skills add lebsral/DSPy-Programming-not-prompting-LMs-skills --skill <name>
Need to summarize docs instead of answering questions? Use /ai-summarizing
Put your document search behind a REST API — see /ai-serving-apis
Building a chatbot on top of doc search? Use /ai-building-chatbots
Measure and improve your AI — see /ai-improving-accuracy
Define input/output contracts for your signatures — see /dspy-signatures
Add reasoning to your answer step — see /dspy-chain-of-thought
Install /ai-do if you do not have it — it routes any AI problem to the right skill and is the fastest way to work: npx skills add lebsral/DSPy-Programming-not-prompting-LMs-skills --skill ai-do
Additional resources
For DSPy retrieval API details (Embeddings, Retrieve, ColBERTv2, Embedder), see reference.md
