Langchain and LlamaIndex interview questions

LangChain: Core Concepts & Applications 🧠

1. What is LangChain? Why is it useful?

   • A: LangChain is a framework for developing applications powered by large language models (LLMs). It simplifies the process of integrating LLMs with external data sources and computation, allowing you to build complex, data-aware, and agentic applications.

2. Explain the key components of LangChain.

   • A: The main components are: Models (interface with LLMs), Prompts (template and manage inputs), Chains (combine LLM calls and other components), Retrieval (access data from external sources), Agents (dynamically decide actions and tool usage), and Memory (store conversation history).

3. What are Chains in LangChain? How do they work?

   • A: Chains are a sequence of actions where the output of one step becomes the input for the next. They allow you to combine multiple components, such as a prompt template and an LLM, into a single, reusable workflow. For example, a LLMChain combines a prompt and an LLM.

4. What is the difference between a Chain and an Agent?

   • A: A Chain follows a predefined, fixed sequence of steps. An Agent, on the other hand, uses an LLM to dynamically decide which actions to take and in what order, based on the user's input. It has access to a set of Tools to perform these actions (e.g., search the web, query a database).

5. How do you handle conversational context in a LangChain application?

   • A: You use Memory modules. LangChain offers different types, like ConversationBufferMemory which stores the entire conversation history, or ConversationSummaryMemory which summarizes past conversations to save on token usage.

6. Explain Retrieval-Augmented Generation (RAG) and its role in LangChain.

   • A: RAG is a technique that retrieves relevant information from a custom knowledge base and provides it to the LLM as additional context to generate more accurate, grounded answers. LangChain makes it easy to build RAG pipelines by connecting a retriever (like a vector store) to an LLM.

7. What are embeddings and why are they important in LangChain's RAG system?

   • A: Embeddings are numerical vector representations of text. They capture the semantic meaning of the words. In RAG, they're used to convert documents into vectors, which are then stored in a vector database. When a user asks a question, their query is also converted to a vector, and a similarity search is performed to find the most relevant document chunks.

8. What is a PromptTemplate and why is it used?

   • A: A PromptTemplate is used to create and manage prompts efficiently. It allows you to define a prompt with placeholders for variables, so you can dynamically insert user input or retrieved information before sending it to the LLM.

9. How do you load and process different types of documents in LangChain?

   • A: LangChain provides Document Loaders for various data types (e.g., PDFs, web pages, CSVs). After loading, you use Text Splitters to break down large documents into smaller, manageable chunks that are better suited for embedding and retrieval.

10. Name three types of LangChain agents and when you would use them.

    • A:

      • ReAct Agent: Uses reasoning (Thought) and action (Action) steps to solve complex problems, like a multi-step logic task.

      • OpenAIFunctions Agent: Relies on the function-calling capabilities of OpenAI models to select and use tools.

      • StructuredTool Agent: Used for agents that need to use tools with a well-defined and structured input.

11. How would you debug a LangChain application?

    • A: You can use LangSmith, a platform specifically designed for debugging, testing, and monitoring LLM applications built with LangChain. You can also use standard Python logging or the debug=True parameter in chains to see the intermediate steps.

12. What is LangChain Expression Language (LCEL)?

    • A: LCEL is a declarative way to compose chains. It offers a more flexible and efficient method to build complex workflows by "chaining" components together using a pipeline-like syntax (|), making your code more readable and easily runnable in parallel.

13. What is a VectorStore? Give an example.

    • A: A VectorStore is a database optimized for storing and searching vector embeddings. It's a crucial part of a RAG system. Examples include FAISS, ChromaDB, and Pinecone.

14. How do you add a custom tool for a LangChain agent?

    • A: You can create a custom tool by decorating a Python function with @tool or by subclassing the BaseTool class. The tool should have a docstring that clearly describes its purpose for the LLM.

15. What is the RetrievalQA chain?

    • A: The RetrievalQA chain is a pre-built chain in LangChain designed specifically for question-answering over a knowledge base. It handles the full RAG pipeline: taking a user query, retrieving relevant documents, and feeding them to the LLM to generate an answer.

---

LlamaIndex: Data-Centric Framework 📁

16. What is LlamaIndex? What is its primary purpose?

    • A: LlamaIndex is a data framework designed to connect your custom data sources to large language models. Its primary purpose is to simplify the creation of RAG applications by providing an efficient way to ingest, index, and query your private data.

17. Explain the key components of LlamaIndex.

    • A: The core components are: Data Loaders (ingest data from various sources), Documents (the raw data), Nodes (text chunks from documents), Indexes (data structures for querying nodes), and Query Engines (retrieve and synthesize information from indexes).

18. How does LlamaIndex handle different types of data?

    • A: LlamaIndex uses Data Loaders (also known as LlamaHub connectors) to ingest data from diverse sources like PDFs, databases, APIs, and web pages. It then converts this raw data into a universal Document format.

19. What is the difference between a Document and a Node in LlamaIndex?

    • A: A Document is the raw data object, such as a full PDF file. A Node is a smaller, chunked piece of a document. LlamaIndex processes data at the node level, making it easier to embed and retrieve. A single document can contain many nodes.

20. What is an Index in LlamaIndex? Why is it crucial?

    • A: An Index is a data structure that helps LlamaIndex quickly retrieve relevant information for a given query. It's the core of the framework's retrieval capabilities. The most common type is a VectorStoreIndex.

21. How do you create a VectorStoreIndex?

    • A: You first load your data into Documents and then call VectorStoreIndex.from_documents(). LlamaIndex handles the process of chunking the documents, creating embeddings for each chunk, and storing them in a vector store.

22. What is a QueryEngine in LlamaIndex?

    • A: A QueryEngine is the component that takes a user query and returns a response. It wraps an Index and handles the entire retrieval and response synthesis process. It retrieves relevant nodes from the index and passes them to the LLM to generate the final answer.

23. How does LlamaIndex handle complex queries like those that require a summary of multiple documents?

    • A: LlamaIndex's query engine can handle this by using a "query transformation" or a "sub-query" approach. It can break down a complex query into smaller parts, execute each part, and then synthesize a final answer from the results.

24. Can you use LlamaIndex without a vector database? If so, how?

    • A: Yes. LlamaIndex offers various index types. For instance, the ListIndex stores documents sequentially and performs a simple linear scan, and the KeywordTableIndex uses keywords for retrieval. While vector stores are the most common, they're not the only option.

25. What is the purpose of retrievers and node postprocessors in LlamaIndex?

    • A: A retriever is the part of the query engine that fetches the most relevant nodes from an index. Node postprocessors are applied after retrieval to refine the retrieved nodes, for example, by re-ranking them to ensure the most relevant ones are at the top.

26. What is the ServiceContext object?

    • A: The ServiceContext is a container object that holds common services and components like the LLM, embedding model, and chunking TextSplitter. It's used to configure and pass these services around your LlamaIndex application.

27. How would you handle a question-answering system over a private PDF document?

    • A:

      1. Use a PDF DocumentLoader to load the file.

      2. Create a VectorStoreIndex from the document.

      3. Create a QueryEngine from the index.

      4. Call the query engine with the user's question.

28. Explain the role of metadata in LlamaIndex documents.

    • A: Metadata is extra information attached to a Document or Node, such as the source file name, page number, or creation date. It can be used to filter or customize retrieval, for example, by only searching documents from a specific author.

29. What's the difference between simple VectorStoreIndex and a SummaryIndex?

    • A: A VectorStoreIndex is for retrieving specific, relevant chunks of data. A SummaryIndex (or ListIndex), on the other hand, is designed for a linear traversal or summary of the entire document. You would use a VectorStoreIndex for Q&A and a SummaryIndex for tasks like summarization.

30. What is LlamaHub?

    • A: LlamaHub is a repository of DataLoaders and Tools contributed by the community. It provides a vast collection of connectors to easily load data from a wide variety of sources, from YouTube videos to Google Docs.

---

LangChain vs. LlamaIndex & Practical Use Cases 💻

31. What is the fundamental difference in focus between LangChain and LlamaIndex?

    • A: LangChain is a general-purpose framework for building complex LLM-powered applications. It focuses on the logic, orchestration, and agency of an application (what tools to use, what steps to take). LlamaIndex is a data framework that specializes in ingestion, indexing, and retrieval from private data.

32. In what scenarios would you choose LangChain over LlamaIndex?

    • A: Choose LangChain when you need to build complex applications that require multiple steps, like:

      • An agent that can dynamically decide to search the web, query a database, or perform a calculation.

      • A multi-step conversational bot that remembers past conversations and interacts with various tools.

33. In what scenarios would you choose LlamaIndex over LangChain?

    • A: Choose LlamaIndex when your primary goal is to perform efficient question-answering over your own large, private dataset. It is highly optimized for this RAG use case, offering advanced indexing and querying capabilities out-of-the-box.

34. Can LangChain and LlamaIndex be used together? If so, how?

    • A: Yes, they are highly complementary. A common pattern is to use LlamaIndex for the data ingestion and retrieval part of the RAG pipeline, and then use LangChain for the conversational and orchestration logic around it. LlamaIndex can be used as a Retriever within a LangChain Chain.

35. Give a real-world use case for a data science project that would use both frameworks.

    • A: Building a corporate knowledge base chatbot. You would use:

      • LlamaIndex to load and index all internal documents (HR policies, project reports, technical guides) into a vector store.

      • LangChain to create a conversational agent that uses the LlamaIndex query engine as a Tool to answer employee questions. This agent can also perform other actions, like creating a help ticket or summarizing a meeting.

---

General & Advanced Concepts 🚀

36. What is prompt engineering?

    • A: Prompt engineering is the process of crafting and refining prompts to get the desired output from a large language model. It's about providing clear instructions, context, and examples to guide the model's response.

37. What is a few-shot prompt?

    • A: A few-shot prompt provides the LLM with a few examples of input-output pairs to help it understand the task and generate a better response, as opposed to a zero-shot prompt which provides no examples.

38. Explain what LLM hallucination is and how RAG helps mitigate it.

    • A: Hallucination is when an LLM generates factually incorrect or nonsensical information. RAG helps mitigate this by providing the model with a grounded, verifiable source of truth from your own data, so it relies on the retrieved context rather than its pre-trained knowledge.

39. What are the main steps in a RAG pipeline?

    • A:

      1. Ingestion/Loading: Load data from various sources (PDFs, docs, etc.).

      2. Indexing: Chunk the data, embed the chunks, and store them in a vector store.

      3. Retrieval: Take a user query, embed it, and search the vector store for the most relevant chunks.

      4. Generation: Pass the retrieved chunks and the user query to the LLM to generate the final response.

40. How do you handle long documents efficiently in a RAG pipeline?

    • A: You use text splitters to break the document into smaller, overlapping chunks. The chunks should be small enough to fit within the LLM's context window but large enough to retain context. Overlapping helps ensure that semantic meaning is not lost at the chunk boundaries.

41. What is a Callback in LangChain and why is it useful?

    • A: A Callback is a function that can be triggered at different stages of a chain or agent's execution (e.g., at the start of a chain, after a tool is called). They are useful for logging, monitoring, and debugging an application.

42. What are Retrievers and QueryEngine in LlamaIndex, and how do they work together?

    • A: A Retriever fetches Nodes from an Index based on a user query. A QueryEngine is a high-level component that wraps a Retriever and an LLM, taking the retrieved nodes and synthesizing the final answer. The query engine is what the user interacts with, while the retriever is an internal component.

43. How does LlamaIndex support multi-modal data?

    • A: LlamaIndex has various data loaders and indexing strategies for multi-modal data. For example, it can extract text from images and tables, enabling you to build a RAG system over PDFs that contain both text and images.

44. What are OutputParsers in LangChain?

    • A: OutputParsers are used to structure and validate the raw text output from an LLM. For example, you can use an OutputParser to parse the LLM's response into a JSON object or a Python dictionary, making it easier to use in subsequent steps.

45. What is the FAISS vector store, and why is it popular?

    • A: FAISS (Facebook AI Similarity Search) is a library for efficient similarity searching and clustering of dense vectors. It's popular because it's open-source, fast, and can be run locally on a machine, making it a great choice for smaller-scale projects.

46. How would you evaluate the performance of a RAG system?

    • A: You can evaluate a RAG system using metrics like:

      • Relevance: Is the retrieved context relevant to the query?

      • Correctness: Is the generated answer factually correct based on the retrieved context?

      • Context Adherence: Does the answer only use information from the provided context?

      • Latency: How fast is the system's response time?

47. What is the role of metadata filtering in RAG?

    • A: Metadata filtering is a powerful technique that allows you to pre-filter documents based on their metadata (e.g., date, author, source) before performing a vector search. This makes retrieval more accurate and efficient by reducing the search space.

48. Describe a scenario where a SQLDatabaseChain in LangChain would be useful.

    • A: A SQLDatabaseChain is useful for building applications that can answer questions over structured data in a SQL database. The LLM translates a natural language query ("How many users signed up last month?") into a SQL query, executes it, and then uses the results to formulate a human-readable answer.

49. What are the common challenges when building LLM applications with these frameworks?

    • A:

      • Hallucinations: The model can still generate incorrect information.

      • Cost & Latency: API calls to LLMs can be expensive and slow.

      • Token Limits: Handling long documents and conversations can exceed the LLM's context window.

      • Prompt Injection: A malicious user can craft a prompt to override the system instructions.

      • Deployment: Putting a full RAG system into production requires careful consideration of infrastructure and scalability.

50. How do these frameworks support building a Chatbot?

    • A: Both provide components for building a chatbot. LangChain excels at the conversational flow and memory management, while LlamaIndex is used for integrating the chatbot with a knowledge base. A hybrid approach often yields the best results.