LangChain is a powerful framework designed to simplify the development of applications powered by large language models (LLMs) like GPT-4, Claude, or Llama. Think of it as a toolkit that helps developers connect AI models to real-world data sources, create complex workflows, and build intelligent applications more efficiently.

Why Use LangChain?

The Problem LangChain Solves

Working with LLMs directly can be challenging:

• Limited Context: LLMs have knowledge cutoff dates and can't access real-time information.

• No Memory: Each interaction is independent - the model doesn't remember previous conversations.

• Complex Workflows: Building multi-step AI applications requires managing chains of operations.

• Data Integration: Connecting LLMs to your own data sources is complicated.

The LangChain Solution

LangChain addresses these challenges by providing:

• Data Connectivity: Easy integration with databases, APIs, and documents.

• Memory Management: Built-in conversation memory and context management.

• Chain Operations: Tools to create complex, multi-step workflows.

• Agent Capabilities: Ability for AI to use tools and make decisions

Core Concepts

Chains

Chains are the backbone of LangChain applications. They represent sequences of operations that process input through multiple steps, allowing you to build complex workflows by connecting different components together.

How Chains Work: Think of a chain like a factory assembly line. Each step in the chain performs a specific task and passes the result to the next step:

User Question → Document Retrieval → Context Creation → LLM Response

Prompts

Prompts are instructions you give to the language model. LangChain's prompt templates make it easy to create reusable, dynamic prompts that can be customized for different situations.

Why Prompt Templates Matter:

• Consistency: Same format across your application

• Reusability: Write once, use many times

• Dynamic Content: Insert variables based on user input

• Easy Testing: Modify prompts without changing code

from langchain.prompts import PromptTemplate

template = "You are a helpful assistant. Answer the question: {question}"
prompt = PromptTemplate(
    input_variables=["question"],
    template=template
)

# Generate the actual prompt
formatted_prompt = prompt.format(question="What is Python?")
print(formatted_prompt)
# Output: "You are a helpful assistant. Answer the question: What is Python?"

Memory

Memory is what makes your AI applications feel more natural and conversational. Without memory, each interaction with your AI is completely independent - it won't remember what you talked about just moments ago.

Agents

Agents are the "smart" part of LangChain - they can think, plan, and decide which tools to use to accomplish a task. Unlike chains (which follow a fixed sequence), agents can dynamically choose their next action based on the situation.

How Agents Work:

1. Observe: Look at the current situation

2. Think: Decide what to do next

3. Act: Use a tool or provide an answer

4. Repeat: Continue until the task is complete

Agent Components:

• LLM: The "brain" that makes decisions

• Tools: Functions the agent can use (search, calculator, database query, etc.)

• Agent Type: The reasoning strategy (ReAct, Plan-and-Execute, etc.)

Retrievers

Retrievers are specialized components that find relevant information from large datasets or document collections. They're essential for building applications that can answer questions about your own data.

How Retrievers Work:

1. Index Creation: Documents are processed and stored in a searchable format

2. Query Processing: User questions are converted into search queries

3. Similarity Search: Find documents most relevant to the query

4. Return Results: Provide the most relevant documents or passages

Getting Started: Installation and Setup

Installing LangChain

pip install langchain
pip install openai  # or your preferred LLM provider

Basic Setup

import os
from langchain.llms import OpenAI

# Set your API key
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

# Initialize the language model
llm = OpenAI(temperature=0.7)

Your First LangChain Application

Let's build a simple question-answering application:

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# Initialize the language model
llm = OpenAI(temperature=0.7)

# Create a prompt template
template = """
You are a helpful AI assistant. Please answer the following question clearly and concisely:

Question: {question}
Answer:
"""

prompt = PromptTemplate(
    input_variables=["question"],
    template=template
)

# Create a chain
chain = LLMChain(llm=llm, prompt=prompt)

# Use the chain
response = chain.run("What is artificial intelligence?")
print(response)

Common LangChain Components

Document Loaders

Load data from various sources:

from langchain.document_loaders import TextLoader, PDFLoader, WebBaseLoader

# Load a text file
loader = TextLoader("my_document.txt")
documents = loader.load()

# Load a PDF
pdf_loader = PDFLoader("my_document.pdf")
pdf_docs = pdf_loader.load()

Text Splitters

Break large documents into manageable chunks:

from langchain.text_splitter import CharacterTextSplitter

text_splitter = CharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
texts = text_splitter.split_documents(documents)

Vector Stores

Store and search documents using embeddings:

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma

embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)

Retrieval QA

Create a question-answering system over your documents:

from langchain.chains import RetrievalQA

qa = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

response = qa.run("What does the document say about AI?")

Building a Complete RAG Application

RAG (Retrieval-Augmented Generation) is one of the most popular LangChain use cases. Here's a complete example:

from langchain.llms import OpenAI
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA

# 1. Load your documents
loader = TextLoader("knowledge_base.txt")
documents = loader.load()

# 2. Split documents into chunks
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# 3. Create embeddings and vector store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)

# 4. Create the QA chain
llm = OpenAI(temperature=0)
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

# 5. Ask questions
question = "What are the main topics covered in the document?"
answer = qa_chain.run(question)
print(answer)

Memory in LangChain

Add conversation memory to maintain context:

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# Create memory
memory = ConversationBufferMemory()

# Create conversation chain with memory
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# Have a conversation
response1 = conversation.predict(input="Hi, my name is John")
response2 = conversation.predict(input="What's my name?")

Error Handling and Debugging

Common Issues and Solutions

• API Key Errors: Ensure your API keys are properly set in environment variables.

• Token Limits: Monitor input/output token usage and implement chunking strategies.

• Slow Performance: Consider using smaller models or implementing caching.

• Memory Issues: Clear memory periodically in long conversations.

Debugging Tips

# Enable verbose mode to see what's happening
chain = LLMChain(llm=llm, prompt=prompt, verbose=True)

# Add error handling
try:
    response = chain.run(question)
except Exception as e:
    print(f"Error: {e}")

LangChain simplifies the process of building sophisticated AI applications by providing a comprehensive framework for working with language models. Whether you're building a simple chatbot or a complex document analysis system, LangChain's modular approach and extensive library of components make it easier to create powerful, production-ready applications.

Start with the basics, experiment with different components, and gradually build more complex applications as you become comfortable with the framework. The key to success with LangChain is understanding how to chain together different components to create workflows that solve real-world problems.

Remember that LangChain is rapidly evolving, so stay updated with the latest documentation and community resources to make the most of this powerful framework.

අපි මේ ලිපියෙන් බලමු:

• React Compiler කියන්නේ මොකක්ද?

• React Compiler භාවිතා කරන්න ඕනේ ඇයි?

• React Compiler භාවිතා කරන්නේ කොහොමද?

• React Compiler භාවිතා කිරීමෙන් ලැබෙන ප්‍රතිලාභ මොනවාද?

React Compiler කියන්නේ මොකක්ද?

React Compiler ගැන යන්න කලින්, මුලින්ම බලමු “Compile” කියන්නේ මොකක්ද කියලා.

Compile කියන්නේ අපි ලියපු source code (උදාහරණයක් විදිහට JavaScript, TypeScript, C++ code) එක computer එකට තේරෙන machine code හෝ optimized instructions වලට පරිවර්තනය කරන විශේෂ program එකක්.

• TypeScript compiler → TypeScript code එක JavaScript එකට badagena denawa.

• Babel → modern JavaScript code එක backward-compatible JavaScript එකට badagena denawa.

• C++ compiler → C++ code එක CPU එකට තේරෙන machine code එකට badagena denawa.

සරලව කියනවනම්:
Compile කියන්නේ → “අපිට හොඳට කියවෙන්න පුළුවන් code එක, computer එකට තේරෙන ආකාරයට පරිවර්තනය කරන process එක.”

දැන් බලමු React Compiler කියන්නේ මොකක්ද කියලා.

React වලදි අවශ්‍ය නොවන re-rendering වළක්වාගන්න අපිට memo, useMemo, useCallback භාවිතා කරන්න පුළුවන්. නමුත් ඒවා බොහෝ විට code එක සංකීර්ණ කරනවා, සහ වැරදි ලෙස භාවිතා වීමේ අවදානමක් තියෙනවා.

React Compiler භාවිතයෙන් මේ ගැටළු වලට විසඳුමක් ලැබෙනවා. React Compiler කියන්නේ static compiler එකක්. මේක ඔයාගේ components build time එකේදීම ස්වයංක්‍රීයව optimize කරනවා. ඒ කියන්නේ ඔයා performance hacks (memo, useMemo, useCallback) තැන තැන දාන්න ඕනේ වෙන්නේ නැහැ. React Compiler තමන්ම code එක analyze කරලා, අවශ්‍ය optimizations යොදනවා.

React Compiler භාවිතා කරන්න ඕනේ ඇයි?

React Compiler එක භාවිතා කිරීම මගින් ලැබෙන advantages ගැන කතා කරන්න කලින්, පහල sample code දෙකේ වෙනස බලන්න.

🔴 Manual Optimization (Compiler එකට කලින්)

import React, { useState, useCallback, memo } from "react";

const Button = memo(({ onClick }) => {
  console.log("Button rendered");
  return <button onClick={onClick}>Increment</button>;
});

export default function App() {
  const [count, setCount] = useState(0);

  const handleClick = useCallback(() => {
    setCount((c) => c + 1);
  }, []);

  return (
    <div>
      <h1>Count: {count}</h1>
      <Button onClick={handleClick} />
    </div>
  );
}

මෙහිදී memo සහ useCallback manually use කරන්න වෙනවා unnecessary re-renders වළක්වා ගන්න.

🟢 Automatic Optimization (React Compiler මගින්)

import React, { useState } from "react";

function Button({ onClick }) {
  console.log("Button rendered");
  return <button onClick={onClick}>Increment</button>;
}

export default function App() {
  const [count, setCount] = useState(0);

  const handleClick = () => {
    setCount((c) => c + 1);
  };

  return (
    <div>
      <h1>Count: {count}</h1>
      <Button onClick={handleClick} />
    </div>
  );
}

React Compiler එකේ Advantages

• Automatic Memoization:

  memo හෝ useCallback වගේ hacks manual add කරන්න ඕනේ නෑ. React Compiler එක විසින් code එක analyze කරලා අවශ්‍ය වෙලාවට memoization handle කරනවා.

• Cleaner Code:

  useCallback සහ useMemo wrappers අඩු වෙන නිසා code එක සරල වීම සහා maintain කරන්න ලේසි වෙනවා.

• Optimize Performance:

  Build time එකේදිම compiler එක අවශ්‍ය optimizations යොදනවන නිසා අනවශ්‍ය re-render වැලකීම මගින් application එක හොද performance level එකකින් වැඩ කරනවා.

• Better Developer Experience:
  Developers ලට performance hacks ගැන වැඩි අවදානයක් දෙන්නේ නැතුව features develop කරන එක focused කරන්න පුළුවන්.

Limitations

• හැම situation එකකම compiler automatic optimize කරන්නේ නෑ.

• Complex objects, refs, context-heavy usage වගේ තැන්ව ලදී developer intervention අවශ්‍ය වෙන්න පුළුවන්.