LangChain and AI Application Development practice questions

Disable caching to ensure fresh responses

Why wrong: Disabling caching increases the number of API calls, worsening rate limiting issues.

Increase the max_tokens parameter to reduce the number of calls

Why wrong: max_tokens controls response length, not the number of API calls; increasing it does not reduce call frequency.

Set the model temperature to 0

Why wrong: Temperature affects randomness of output, not API call frequency or rate limit handling.

Retriever (e.g., vectorstore.as_retriever())

Why wrong: Retriever is used at query time to fetch relevant documents, not during ingestion.

LLM (e.g., ChatOCIGenAI)

Why wrong: LLM is used for generation, not for creating embeddings during ingestion.

Use a Python dictionary as the memory store

Why wrong: A dictionary is in-memory and lost when the application stops.

Use AgentExecutor with a custom tool for history

Why wrong: AgentExecutor orchestrates agent execution; it does not persist history on its own.

Save the conversation to a local .txt file

Why wrong: While possible, this is not a standard or efficient approach for LangChain memory; it would require custom parsing and lacks structured access.

build_retriever()

Why wrong: build_retriever() is not a method.

to_retriever()

Why wrong: to_retriever() is not a method in LangChain.

get_retriever()

Why wrong: get_retriever() is not a method; as_retriever() is correct.

Bitmap index

Why wrong: Incorrect: Bitmap indexes are used for low-cardinality columns, not for vector similarity search.

B-tree index

Why wrong: Incorrect: B-tree indexes are for exact match or range queries on scalar data, not for vector similarity.

HNSW index

Why wrong: Incorrect: HNSW is an approximate index designed for fast approximate nearest neighbor search. It does not guarantee exact results, so it does not meet the requirement for exact nearest neighbor queries.

PDFLoader

Why wrong: PDFLoader is for PDF files.

CSVLoader

Why wrong: CSVLoader is for CSV files.

TextLoader

Why wrong: TextLoader is for plain text files.

Check the model's token limit

Why wrong: Token limit is unrelated to parameter format issues.

Increase the chunk size in the text splitter

Why wrong: Chunk size is irrelevant to agent tool usage.

Increase the similarity score threshold

Why wrong: Threshold filtering only removes low-similarity documents; it does not diversify the selected set.

Increase chunk_overlap in the text splitter

Why wrong: chunk_overlap affects chunk boundaries, not retrieval diversity; it can increase redundancy if set too high.

Reduce chunk_size in the text splitter

Why wrong: Smaller chunks may reduce overlap but do not directly address duplicate documents at retrieval time.

Manually call the first chain, extract the output, and pass it to the second chain

Why wrong: While this works, it is not using SequentialChain as requested.

Set the input_variables of the second chain to match the output_variables of the first chain in a SequentialChain

Why wrong: SequentialChain requires you to explicitly declare and match variable names across every chain's input_variables and output_variables, because it's designed to support multiple named inputs/outputs threading through the sequence. Since this pipeline is strictly one input to one output at each step, SimpleSequentialChain skips that variable-name bookkeeping entirely and pipes each chain's output straight into the next chain's input automatically.

Define two separate LLMChains and combine them with the | operator in LCEL

Why wrong: The | operator is for LCEL, not SequentialChain. While this could work, the question specifically asks about SequentialChain configuration.

The chunk_size in the text splitter is too large

Why wrong: Chunk size affects retrieval granularity but does not directly cause the LLM to ignore retrieved context.

The embedding model is not compatible with the retriever

Why wrong: Embedding compatibility affects retrieval quality but not the generation step; the LLM could still ignore good retrieved context.

The retriever is returning irrelevant documents

Why wrong: If retrieval were irrelevant, the answers would likely be unrelated but still based on what was retrieved; ungrounded answers suggest the LLM is not using the retrieved context.

WebBaseLoader

Why wrong: WebBaseLoader is used to load web content, not PDF documents, so it is not essential for this PDF RAG pipeline.

OracleVS

Why wrong: OracleVS stores and retrieves embeddings, but without an embeddings model the pipeline cannot function; it is not one of the two most essential components.

OCIGenAI

Why wrong: OCIGenAI is a wrapper for LLMs, not for generating embeddings, and is not essential for this pipeline.

Use AgentType.ZERO_SHOT_REACT_DESCRIPTION to simplify the agent's reasoning

Why wrong: Agent type selection does not directly address error handling or logging.

Set verbose=True in the AgentExecutor to show all reasoning steps to end users

Why wrong: verbose exposes internal chain-of-thought, which is not suitable for production user-facing applications.

Use a larger foundation model with a longer context window and paste all documents into each prompt

Why wrong: Pasting all documents into every prompt is expensive, hits context limits for large document sets, and does not scale as the document library grows.

Fine-tune a base LLM on the policy documents monthly

Why wrong: Fine-tuning is expensive and time-consuming; monthly cycles are impractical and fine-tuned knowledge becomes stale immediately after cutoff.

Train a custom model from scratch on the policy documents each month

Why wrong: Training from scratch requires massive compute resources and weeks of time — entirely disproportionate for monthly document updates.

The chunk_overlap is too low; increase overlap to preserve sentence boundary

Why wrong: Overlap only affects the next chunk's starting context; it does not affect where the current chunk ends.

The chunk_size is too small; increase it to avoid incomplete sentences

Why wrong: Incomplete sentences occur because the splitter cannot find a separator within the limit, not because the limit is too small.

TokenTextSplitter should be used instead because it respects token boundaries

Why wrong: TokenTextSplitter splits on tokens, not characters, but can still cut sentences at token boundaries.

ConversationalRetrievalChain

Why wrong: ConversationalRetrievalChain adds memory for chat history; overkill if only single-turn retrieval is needed.

SequentialChain

Why wrong: SequentialChain runs multiple chains in order but does not inherently include retrieval.

LLMChain

Why wrong: LLMChain does not include retrieval; it only passes a prompt to an LLM.

IVF with quantization and probes=5

Why wrong: Quantization may save memory but can reduce recall, and probes=5 is too low for a 10M dataset, likely resulting in poor recall.

HNSW with neighbors=32

Why wrong: While HNSW is fast, neighbors=32 is relatively low and may reduce recall; higher neighbors like 64 give better recall at marginal latency cost.

IVF with probes=10

Why wrong: IVF generally has higher latency than HNSW for a given recall level; probes=10 may be insufficient for high recall.

top_k

Why wrong: top_k controls the number of results, not their diversity.

similarity_search

Why wrong: Similarity search returns top-k most similar results, which can be redundant.

chunk_overlap

Why wrong: Chunk overlap affects chunking, not retrieval diversity.

WHERE embedding SIMILAR TO :query_vec TOP 5

Why wrong: SIMILAR TO is not valid for vector distance; it's for string patterns.

ORDER BY VECTOR_COMPARE(embedding, :query_vec) LIMIT 5

Why wrong: VECTOR_COMPARE is not a valid Oracle function; use VECTOR_DISTANCE.

WHERE KNN(embedding, :query_vec, 5)

Why wrong: KNN is not valid SQL syntax in Oracle; the correct function is VECTOR_DISTANCE.

Use a callback handler attached to the LLM to capture input documents

Why wrong: Callbacks on the LLM only see the final prompt, not the intermediate retrieved documents.

Add a separate logging service that intercepts the chain's output

Why wrong: Intercepting the output would only log the final answer, not the retrieved documents.

Modify the retriever's internal code to add logging

Why wrong: Modifying the retriever is invasive and not composable; LCEL encourages external transformation.

OCIGenAI

Why wrong: OCIGenAI is the wrapper for text completion (LLM) models, not chat models.

ChatOpenAI

Why wrong: ChatOpenAI is for OpenAI, not OCI.

OCIGenAIEmbeddings

Why wrong: This is for embedding models, not text generation.